@bravemobile/react-native-code-push 13.0.0 → 13.1.0-beta.0

package/cpp/binarypatch/vendor/HDiffPatch/libHDiffPatch/HPatch/patch.c

@@ -0,0 +1,3315 @@
+//patch.c
+//
+/*
+ The MIT License (MIT)
+ Copyright (c) 2012-2018 HouSisong
+
+ Permission is hereby granted, free of charge, to any person
+ obtaining a copy of this software and associated documentation
+ files (the "Software"), to deal in the Software without
+ restriction, including without limitation the rights to use,
+ copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the
+ Software is furnished to do so, subject to the following
+ conditions:
+
+ The above copyright notice and this permission notice shall be
+ included in all copies of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ OTHER DEALINGS IN THE SOFTWARE.
+*/
+#include "patch.h"
+#if (_IS_NEED_CACHE_OLD_BY_COVERS)
+#   include <stdlib.h> //qsort
+#endif
+#include "patch_private.h"
+#include "hpatch_mt/hpatch_mt.h"
+#if (_HPATCH_IS_USED_MULTITHREAD)
+#   include "hpatch_mt/_hcache_window_old_mt.h"
+#   include "hpatch_mt/_hinput_mt.h"
+#endif
+
+#ifndef _IS_RUN_MEM_SAFE_CHECK
+#   define _IS_RUN_MEM_SAFE_CHECK  1
+#endif
+
+#if (_IS_RUN_MEM_SAFE_CHECK)
+// __RUN_MEM_SAFE_CHECK : enables bounds checking for memory access to defend against potentially corrupted or maliciously crafted data.
+#   define __RUN_MEM_SAFE_CHECK
+#endif
+
+#ifdef __RUN_MEM_SAFE_CHECK
+#   define  _SAFE_CHECK_DO(code)    do{ if (!(code)) return _hpatch_FALSE; }while(0)
+#else
+#   define  _SAFE_CHECK_DO(code)    do{ code; }while(0)
+#endif
+
+#define _hpatch_FALSE   hpatch_FALSE
+//hpatch_uint __hpatch_debug_check_false_x=0; //for debug
+//#define _hpatch_FALSE (1/__hpatch_debug_check_false_x)
+
+typedef unsigned char TByte;
+
+
+//Variable-length positive integer encoding scheme (x bits for additional type flags, x<=7), outputs 1--n bytes from high:
+// x0*  7-x bit
+// x1* 0*  7+7-x bit
+// x1* 1* 0*  7+7+7-x bit
+// x1* 1* 1* 0*  7+7+7+7-x bit
+// x1* 1* 1* 1* 0*  7+7+7+7+7-x bit
+// ......
+hpatch_BOOL hpatch_packUIntWithTag(TByte** out_code,TByte* out_code_end,
+                                   hpatch_StreamPos_t uValue,hpatch_uint highTag,
+                                   const hpatch_uint kTagBit){//write out integer and advance pointer.
+    TByte*          pcode=*out_code;
+    const hpatch_StreamPos_t kMaxValueWithTag=((hpatch_StreamPos_t)1<<(7-kTagBit))-1;
+    size_t bCount=0;
+    assert((0<=kTagBit)&&(kTagBit<=7));
+    assert((highTag>>kTagBit)==0);
+    while ((uValue>>(7*bCount))>kMaxValueWithTag)
+        ++bCount;
+#ifdef __RUN_MEM_SAFE_CHECK
+    if ((size_t)(out_code_end-pcode)<(1+bCount)) return _hpatch_FALSE;
+#endif
+    *pcode++=(TByte)( (TByte)(uValue>>(7*bCount)) | (highTag<<(8-kTagBit))
+                   | (((bCount>0)?1:0)<<(7-kTagBit))  );
+    while (bCount>0) {
+        --bCount;
+        *pcode++=((uValue>>(7*bCount))&((1<<7)-1)) | (TByte)(((bCount>0)?1:0)<<7);
+    }
+    *out_code=pcode;
+    return hpatch_TRUE;
+}
+
+hpatch_uint hpatch_packUIntWithTag_size(hpatch_StreamPos_t uValue,const hpatch_uint kTagBit){
+    const hpatch_StreamPos_t kMaxValueWithTag=((hpatch_StreamPos_t)1<<(7-kTagBit))-1;
+    hpatch_uint size=0;
+    while (uValue>kMaxValueWithTag) {
+        ++size;
+        uValue>>=7;
+    }
+    ++size;
+    return size;
+}
+
+hpatch_BOOL hpatch_unpackUIntWithTag(const TByte** src_code,const TByte* src_code_end,
+                                     hpatch_StreamPos_t* result,const hpatch_uint kTagBit){//read integer and advance pointer.
+#ifdef __RUN_MEM_SAFE_CHECK
+    //const hpatch_uint kPackMaxTagBit=7;
+#endif
+    hpatch_StreamPos_t  value;
+    TByte               code;
+    const TByte*        pcode=*src_code;
+    
+#ifdef __RUN_MEM_SAFE_CHECK
+    //assert(kTagBit<=kPackMaxTagBit);
+    if (src_code_end<=pcode) return _hpatch_FALSE;
+#endif
+    code=*pcode; ++pcode;
+    value=code&((1<<(7-kTagBit))-1);
+    if ((code&(1<<(7-kTagBit)))!=0){
+        do {
+#ifdef __RUN_MEM_SAFE_CHECK
+            if ((value>>(sizeof(value)*8-7))!=0) return _hpatch_FALSE;//cannot save 7bit
+            if (src_code_end==pcode) return _hpatch_FALSE;
+#endif
+            code=*pcode; ++pcode;
+            value=(value<<7) | (code&((1<<7)-1));
+        } while ((code&(1<<7))!=0);
+    }
+    (*src_code)=pcode;
+    *result=value;
+    return hpatch_TRUE;
+}
+
+
+    static hpatch_BOOL _read_mem_stream(const hpatch_TStreamInput* stream,hpatch_StreamPos_t readFromPos,
+                                        unsigned char* out_data,unsigned char* out_data_end){
+        const unsigned char* src=(const unsigned char*)stream->streamImport;
+        hpatch_size_t readLen=out_data_end-out_data;
+#ifdef __RUN_MEM_SAFE_CHECK
+        if (readFromPos>stream->streamSize) return _hpatch_FALSE;
+        if (readLen>(hpatch_StreamPos_t)(stream->streamSize-readFromPos)) return _hpatch_FALSE;
+#endif
+        memcpy(out_data,src+readFromPos,readLen);
+        return hpatch_TRUE;
+    }
+const hpatch_TStreamInput* mem_as_hStreamInput(hpatch_TStreamInput* out_stream,
+                                               const unsigned char* mem,const unsigned char* mem_end){
+    assert(mem<=mem_end);
+    out_stream->streamImport=(void*)mem;
+    out_stream->streamSize=mem_end-mem;
+    out_stream->read=_read_mem_stream;
+    return out_stream;
+}
+
+    // Two-segment memory stream 
+    typedef struct TMem2StreamImport{
+        const unsigned char* seg1_begin;
+        const unsigned char* seg1_end;
+        const unsigned char* seg2_begin;
+        const unsigned char* seg2_end;
+    } TMem2StreamImport;
+
+    static hpatch_BOOL _read_mem2_stream(const hpatch_TStreamInput* stream,hpatch_StreamPos_t readFromPos,
+                                        unsigned char* out_data,unsigned char* out_data_end){
+        const TMem2StreamImport* self=(const TMem2StreamImport*)stream->streamImport;
+        hpatch_size_t readLen=out_data_end-out_data;
+        const size_t seg1Len=(size_t)(self->seg1_end-self->seg1_begin);
+#ifdef __RUN_MEM_SAFE_CHECK
+        if (readFromPos>stream->streamSize) return _hpatch_FALSE;
+        if (readLen>(hpatch_StreamPos_t)(stream->streamSize-readFromPos)) return _hpatch_FALSE;
+#endif
+        while (readLen>0){
+            const unsigned char* src;
+            size_t               srcOffset;
+            size_t               copyLen;
+            if ((size_t)readFromPos<seg1Len){
+                src      =self->seg1_begin;
+                srcOffset=(size_t)readFromPos;
+                copyLen  =seg1Len-srcOffset;
+            }else{
+                src      =self->seg2_begin;
+                srcOffset=(size_t)(readFromPos-seg1Len);
+                copyLen  =(size_t)(self->seg2_end-self->seg2_begin)-srcOffset;
+            }
+            copyLen=copyLen<=readLen?copyLen:readLen;
+            memcpy(out_data,src+srcOffset,copyLen);
+            readFromPos+=(hpatch_StreamPos_t)copyLen;
+            out_data+=copyLen;
+            readLen-=copyLen;
+        }
+        return hpatch_TRUE;
+    }
+
+    static hpatch_inline
+    const hpatch_TStreamInput* mem2_as_hStreamInput(hpatch_TStreamInput* out_stream,TMem2StreamImport* import,
+                                                    const unsigned char* seg1_begin,const unsigned char* seg1_end,
+                                                    const unsigned char* seg2_begin,const unsigned char* seg2_end){
+        assert((seg1_begin<=seg1_end)&&(seg2_begin<=seg2_end));
+        import->seg1_begin=seg1_begin;
+        import->seg1_end  =seg1_end;
+        import->seg2_begin=seg2_begin;
+        import->seg2_end  =seg2_end;
+        out_stream->streamImport=import;
+        out_stream->streamSize=(seg1_end-seg1_begin)+(seg2_end-seg2_begin);
+        out_stream->read=_read_mem2_stream;
+        return out_stream;
+    }
+
+    static hpatch_BOOL _write_mem_stream(const hpatch_TStreamOutput* stream,hpatch_StreamPos_t writeToPos,
+                                         const unsigned char* data,const unsigned char* data_end){
+        unsigned char* out_dst=(unsigned char*)stream->streamImport;
+        hpatch_size_t writeLen=data_end-data;
+#ifdef __RUN_MEM_SAFE_CHECK
+        if (writeToPos>stream->streamSize) return _hpatch_FALSE;
+        if (writeLen>(hpatch_StreamPos_t)(stream->streamSize-writeToPos)) return _hpatch_FALSE;
+#endif
+        memcpy(out_dst+writeToPos,data,writeLen);
+        return hpatch_TRUE;
+    }
+    typedef hpatch_BOOL (*_read_mem_stream_t)(const hpatch_TStreamOutput* stream,hpatch_StreamPos_t readFromPos,
+                                              unsigned char* out_data,unsigned char* out_data_end);
+const hpatch_TStreamOutput* mem_as_hStreamOutput(hpatch_TStreamOutput* out_stream,
+                                                 unsigned char* mem,unsigned char* mem_end){
+    out_stream->streamImport=mem;
+    out_stream->streamSize=mem_end-mem;
+    out_stream->read_writed=(_read_mem_stream_t)_read_mem_stream;
+    out_stream->write=_write_mem_stream;
+    return out_stream;
+}
+
+hpatch_BOOL hpatch_deccompress_mem(hpatch_TDecompress* decompressPlugin,
+                                   const unsigned char* code,const unsigned char* code_end,
+                                   unsigned char* out_data,unsigned char* out_data_end){
+    hpatch_decompressHandle dec=0;
+    hpatch_BOOL result,colose_rt;
+    hpatch_TStreamInput  codeStream;
+    mem_as_hStreamInput(&codeStream,code,code_end);
+    dec=decompressPlugin->open(decompressPlugin,(out_data_end-out_data),
+                               &codeStream,0,codeStream.streamSize);
+    if (dec==0) return _hpatch_FALSE;
+    result=decompressPlugin->decompress_part(dec,out_data,out_data_end);
+    colose_rt=decompressPlugin->close(decompressPlugin,dec);
+    assert(colose_rt);
+    return result;
+}
+
+
+////////
+//patch by memory
+
+static const hpatch_uint kSignTagBit=1;
+
+static hpatch_BOOL _bytesRle_load(TByte* out_data,TByte* out_dataEnd,
+                                  const TByte* rle_code,const TByte* rle_code_end);
+static void addData(TByte* dst,const TByte* src,hpatch_size_t length);
+hpatch_inline
+static hpatch_BOOL _unpackUIntWithTag(const TByte** src_code,const TByte* src_code_end,
+                                      hpatch_size_t* result,const hpatch_uint kTagBit){
+    if (sizeof(hpatch_size_t)==sizeof(hpatch_StreamPos_t)){
+        return hpatch_unpackUIntWithTag(src_code,src_code_end,(hpatch_StreamPos_t*)result,kTagBit);
+    }else{
+        hpatch_StreamPos_t u64=0;
+        hpatch_BOOL rt=hpatch_unpackUIntWithTag(src_code,src_code_end,&u64,kTagBit);
+        hpatch_size_t u=(hpatch_size_t)u64;
+        *result=u;
+#ifdef __RUN_MEM_SAFE_CHECK
+        return rt&(u==u64);
+#else
+        return rt;
+#endif
+    }
+}
+
+#define unpackUIntWithTagTo(puint,src_code,src_code_end,kTagBit) \
+        _SAFE_CHECK_DO(_unpackUIntWithTag(src_code,src_code_end,puint,kTagBit))
+#define unpackUIntTo(puint,src_code,src_code_end) \
+        unpackUIntWithTagTo(puint,src_code,src_code_end,0)
+
+hpatch_BOOL patch(TByte* out_newData,TByte* out_newData_end,
+                  const TByte* oldData,const TByte* oldData_end,
+                  const TByte* serializedDiff,const TByte* serializedDiff_end){
+    const TByte *code_lengths, *code_lengths_end,
+                *code_inc_newPos, *code_inc_newPos_end,
+                *code_inc_oldPos, *code_inc_oldPos_end,
+                *code_newDataDiff, *code_newDataDiff_end;
+    hpatch_size_t  coverCount;
+
+    assert(out_newData<=out_newData_end);
+    assert(oldData<=oldData_end);
+    assert(serializedDiff<=serializedDiff_end);
+    unpackUIntTo(&coverCount,&serializedDiff, serializedDiff_end);
+    {   //head
+        hpatch_size_t lengthSize,inc_newPosSize,inc_oldPosSize,newDataDiffSize;
+        unpackUIntTo(&lengthSize,&serializedDiff, serializedDiff_end);
+        unpackUIntTo(&inc_newPosSize,&serializedDiff, serializedDiff_end);
+        unpackUIntTo(&inc_oldPosSize,&serializedDiff, serializedDiff_end);
+        unpackUIntTo(&newDataDiffSize,&serializedDiff, serializedDiff_end);
+#ifdef __RUN_MEM_SAFE_CHECK
+        if (lengthSize>(hpatch_size_t)(serializedDiff_end-serializedDiff)) return _hpatch_FALSE;
+#endif
+        code_lengths=serializedDiff;     serializedDiff+=lengthSize;
+        code_lengths_end=serializedDiff;
+#ifdef __RUN_MEM_SAFE_CHECK
+        if (inc_newPosSize>(hpatch_size_t)(serializedDiff_end-serializedDiff)) return _hpatch_FALSE;
+#endif
+        code_inc_newPos=serializedDiff; serializedDiff+=inc_newPosSize;
+        code_inc_newPos_end=serializedDiff;
+#ifdef __RUN_MEM_SAFE_CHECK
+        if (inc_oldPosSize>(hpatch_size_t)(serializedDiff_end-serializedDiff)) return _hpatch_FALSE;
+#endif
+        code_inc_oldPos=serializedDiff; serializedDiff+=inc_oldPosSize;
+        code_inc_oldPos_end=serializedDiff;
+#ifdef __RUN_MEM_SAFE_CHECK
+        if (newDataDiffSize>(hpatch_size_t)(serializedDiff_end-serializedDiff)) return _hpatch_FALSE;
+#endif
+        code_newDataDiff=serializedDiff; serializedDiff+=newDataDiffSize;
+        code_newDataDiff_end=serializedDiff;
+    }
+
+    //decode rle ; rle data begin==cur serializedDiff;
+    _SAFE_CHECK_DO(_bytesRle_load(out_newData, out_newData_end, serializedDiff, serializedDiff_end));
+
+    {   //patch
+        const hpatch_size_t newDataSize=(hpatch_size_t)(out_newData_end-out_newData);
+        hpatch_size_t oldPosBack=0;
+        hpatch_size_t newPosBack=0;
+        hpatch_size_t i;
+        for (i=0; i<coverCount; ++i){
+            hpatch_size_t copyLength,addLength, oldPos,inc_oldPos,inc_oldPos_sign;
+            unpackUIntTo(&copyLength,&code_inc_newPos, code_inc_newPos_end);
+            unpackUIntTo(&addLength,&code_lengths, code_lengths_end);
+#ifdef __RUN_MEM_SAFE_CHECK
+            if (code_inc_oldPos>=code_inc_oldPos_end) return _hpatch_FALSE;
+#endif
+            inc_oldPos_sign=(*code_inc_oldPos)>>(8-kSignTagBit);
+            unpackUIntWithTagTo(&inc_oldPos,&code_inc_oldPos, code_inc_oldPos_end, kSignTagBit);
+            if (inc_oldPos_sign==0)
+                oldPos=oldPosBack+inc_oldPos;
+            else
+                oldPos=oldPosBack-inc_oldPos;
+            if (copyLength>0){
+#ifdef __RUN_MEM_SAFE_CHECK
+                if (copyLength>(hpatch_size_t)(newDataSize-newPosBack)) return _hpatch_FALSE;
+                if (copyLength>(hpatch_size_t)(code_newDataDiff_end-code_newDataDiff)) return _hpatch_FALSE;
+#endif
+                memcpy(out_newData+newPosBack,code_newDataDiff,copyLength);
+                code_newDataDiff+=copyLength;
+                newPosBack+=copyLength;
+            }
+#ifdef __RUN_MEM_SAFE_CHECK
+            if ( (addLength>(hpatch_size_t)(newDataSize-newPosBack)) ) return _hpatch_FALSE;
+            if ( (oldPos>(hpatch_size_t)(oldData_end-oldData)) ||
+                 (addLength>(hpatch_size_t)(oldData_end-oldData-oldPos)) ) return _hpatch_FALSE;
+#endif
+            addData(out_newData+newPosBack,oldData+oldPos,addLength);
+            oldPosBack=oldPos;
+            newPosBack+=addLength;
+        }
+
+        if (newPosBack<newDataSize){
+            hpatch_size_t copyLength=newDataSize-newPosBack;
+#ifdef __RUN_MEM_SAFE_CHECK
+            if (copyLength>(hpatch_size_t)(code_newDataDiff_end-code_newDataDiff)) return _hpatch_FALSE;
+#endif
+            memcpy(out_newData+newPosBack,code_newDataDiff,copyLength);
+            code_newDataDiff+=copyLength;
+            //newPosBack=newDataSize;
+        }
+    }
+
+    if (  (code_lengths==code_lengths_end)
+        &&(code_inc_newPos==code_inc_newPos_end)
+        &&(code_inc_oldPos==code_inc_oldPos_end)
+        &&(code_newDataDiff==code_newDataDiff_end))
+        return hpatch_TRUE;
+    else
+        return _hpatch_FALSE;
+}
+
+hpatch_inline static void addData(TByte* dst,const TByte* src,hpatch_size_t length){
+    while (length--) { *dst++ += *src++; }
+}
+
+static hpatch_BOOL _bytesRle_load(TByte* out_data,TByte* out_dataEnd,
+                                  const TByte* rle_code,const TByte* rle_code_end){
+    const TByte*    ctrlBuf,*ctrlBuf_end;
+    hpatch_size_t ctrlSize;
+    unpackUIntTo(&ctrlSize,&rle_code,rle_code_end);
+#ifdef __RUN_MEM_SAFE_CHECK
+    if (ctrlSize>(hpatch_size_t)(rle_code_end-rle_code)) return _hpatch_FALSE;
+#endif
+    ctrlBuf=rle_code;
+    rle_code+=ctrlSize;
+    ctrlBuf_end=rle_code;
+    while (ctrlBuf_end-ctrlBuf>0){
+        enum TByteRleType type=(enum TByteRleType)((*ctrlBuf)>>(8-kByteRleType_bit));
+        hpatch_size_t length;
+        unpackUIntWithTagTo(&length,&ctrlBuf,ctrlBuf_end,kByteRleType_bit);
+#ifdef __RUN_MEM_SAFE_CHECK
+        if (length>=(hpatch_size_t)(out_dataEnd-out_data)) return _hpatch_FALSE;
+#endif
+        ++length;
+        switch (type){
+            case kByteRleType_rle0:{
+                memset(out_data,0,length);
+                out_data+=length;
+            }break;
+            case kByteRleType_rle255:{
+                memset(out_data,255,length);
+                out_data+=length;
+            }break;
+            case kByteRleType_rle:{
+#ifdef __RUN_MEM_SAFE_CHECK
+                if (1>(hpatch_size_t)(rle_code_end-rle_code)) return _hpatch_FALSE;
+#endif
+                memset(out_data,*rle_code,length);
+                ++rle_code;
+                out_data+=length;
+            }break;
+            case kByteRleType_unrle:{
+#ifdef __RUN_MEM_SAFE_CHECK
+                if (length>(hpatch_size_t)(rle_code_end-rle_code)) return _hpatch_FALSE;
+#endif
+                memcpy(out_data,rle_code,length);
+                rle_code+=length;
+                out_data+=length;
+            }break;
+        }
+    }
+    
+    if (  (ctrlBuf==ctrlBuf_end)
+        &&(rle_code==rle_code_end)
+        &&(out_data==out_dataEnd))
+        return hpatch_TRUE;
+    else
+        return _hpatch_FALSE;
+}
+
+//----------------------
+//patch by stream
+
+    static hpatch_BOOL _TStreamInputClip_read(const hpatch_TStreamInput* stream,
+                                              hpatch_StreamPos_t readFromPos,
+                                              unsigned char* out_data,unsigned char* out_data_end){
+        TStreamInputClip* self=(TStreamInputClip*)stream->streamImport;
+#ifdef __RUN_MEM_SAFE_CHECK
+        if (readFromPos+(out_data_end-out_data)>self->base.streamSize) return _hpatch_FALSE;
+#endif
+        return self->srcStream->read(self->srcStream,readFromPos+self->clipBeginPos,out_data,out_data_end);
+    }
+void TStreamInputClip_init(TStreamInputClip* self,const hpatch_TStreamInput*  srcStream,
+                           hpatch_StreamPos_t clipBeginPos,hpatch_StreamPos_t clipEndPos){
+    assert(self!=0);
+    assert(srcStream!=0);
+    assert(clipBeginPos<=clipEndPos);
+    assert(clipEndPos<=srcStream->streamSize);
+    self->srcStream=srcStream;
+    self->clipBeginPos=clipBeginPos;
+    self->base.streamImport=self;
+    self->base.streamSize=clipEndPos-clipBeginPos;
+    self->base.read=_TStreamInputClip_read;
+}
+
+    static hpatch_BOOL _TStreamOutputClip_write(const hpatch_TStreamOutput* stream,
+                                                hpatch_StreamPos_t writePos,
+                                                const unsigned char* data,const unsigned char* data_end){
+    TStreamOutputClip* self=(TStreamOutputClip*)stream->streamImport;
+#ifdef __RUN_MEM_SAFE_CHECK
+    if (writePos+(data_end-data)>self->base.streamSize) return _hpatch_FALSE;
+#endif
+    return self->srcStream->write(self->srcStream,writePos+self->clipBeginPos,data,data_end);
+}
+
+void TStreamOutputClip_init(TStreamOutputClip* self,const hpatch_TStreamOutput*  srcStream,
+                            hpatch_StreamPos_t clipBeginPos,hpatch_StreamPos_t clipEndPos){
+    assert(self!=0);
+    assert(srcStream!=0);
+    assert(clipBeginPos<=clipEndPos);
+    assert(clipEndPos<=srcStream->streamSize);
+    self->srcStream=srcStream;
+    self->clipBeginPos=clipBeginPos;
+    self->base.streamImport=self;
+    self->base.streamSize=clipEndPos-clipBeginPos;
+    ((TStreamInputClip*)self)->base.read=_TStreamInputClip_read;
+    self->base.write=_TStreamOutputClip_write;
+}
+
+
+
+//assert(hpatch_kStreamCacheSize>=hpatch_kMaxPluginTypeLength+1);
+struct __private_hpatch_check_kMaxCompressTypeLength {
+    char _[(hpatch_kStreamCacheSize>=(hpatch_kMaxPluginTypeLength+1))?1:-1];};
+
+hpatch_BOOL _TStreamCacheClip_readStr_end(TStreamCacheClip* sclip,TByte endTag,
+                                          char* out_type,size_t typeBufLen){
+    const TByte* type_begin;
+    hpatch_size_t i;
+    hpatch_size_t readLen=typeBufLen;
+    if (readLen>_TStreamCacheClip_leaveSize(sclip))
+        readLen=(hpatch_size_t)_TStreamCacheClip_leaveSize(sclip);
+    type_begin=_TStreamCacheClip_accessData(sclip,readLen);
+    if (type_begin==0) return _hpatch_FALSE;//not found
+    for (i=0; i<readLen; ++i) {
+        if (type_begin[i]!=endTag)
+            continue;
+        else{
+            memcpy(out_type,type_begin,i);  out_type[i]='\0';
+            _TStreamCacheClip_skipData_noCheck(sclip,i+1);
+            return hpatch_TRUE;
+        }
+    }
+    return _hpatch_FALSE;//not found
+}
+
+hpatch_BOOL _TStreamCacheClip_updateCache(TStreamCacheClip* sclip){
+    TByte* buf0=&sclip->cacheBuf[0];
+    const hpatch_StreamPos_t streamSize=sclip->streamPos_end-sclip->streamPos;
+    hpatch_size_t readSize=sclip->cacheBegin;
+    if (readSize>streamSize)
+        readSize=(hpatch_size_t)streamSize;
+    if (readSize==0) return hpatch_TRUE;
+    if (!_TStreamCacheClip_isCacheEmpty(sclip)){
+        memmove(buf0+(hpatch_size_t)(sclip->cacheBegin-readSize),
+                buf0+sclip->cacheBegin,_TStreamCacheClip_cachedSize(sclip));
+    }
+    if (!sclip->srcStream->read(sclip->srcStream,sclip->streamPos,
+                                buf0+(sclip->cacheEnd-readSize),buf0+sclip->cacheEnd))
+        return _hpatch_FALSE;//read error
+    sclip->cacheBegin-=readSize;
+    sclip->streamPos+=readSize;
+    return hpatch_TRUE;
+}
+
+hpatch_BOOL _TStreamCacheClip_skipData(TStreamCacheClip* sclip,hpatch_StreamPos_t skipLongSize){
+    while (skipLongSize>0) {
+        hpatch_size_t len=sclip->cacheEnd;
+        if (len>skipLongSize)
+            len=(hpatch_size_t)skipLongSize;
+        if (_TStreamCacheClip_accessData(sclip,len)){
+            _TStreamCacheClip_skipData_noCheck(sclip,len);
+            skipLongSize-=len;
+        }else{
+            return _hpatch_FALSE;
+        }
+    }
+    return hpatch_TRUE;
+}
+
+//assert(hpatch_kStreamCacheSize>=hpatch_kMaxPackedUIntBytes);
+struct __private_hpatch_check_hpatch_kMaxPackedUIntBytes {
+    char _[(hpatch_kStreamCacheSize>=hpatch_kMaxPackedUIntBytes)?1:-1]; };
+
+hpatch_BOOL _TStreamCacheClip_unpackUIntWithTag(TStreamCacheClip* sclip,hpatch_StreamPos_t* result,const hpatch_uint kTagBit){
+    TByte* curCode,*codeBegin;
+    hpatch_size_t readSize=hpatch_kMaxPackedUIntBytes;
+    const hpatch_StreamPos_t dataSize=_TStreamCacheClip_leaveSize(sclip);
+    if (readSize>dataSize)
+        readSize=(hpatch_size_t)dataSize;
+    codeBegin=_TStreamCacheClip_accessData(sclip,readSize);
+    if (codeBegin==0) return _hpatch_FALSE;
+    curCode=codeBegin;
+    _SAFE_CHECK_DO(hpatch_unpackUIntWithTag((const TByte**)&curCode,codeBegin+readSize,result,kTagBit));
+    _TStreamCacheClip_skipData_noCheck(sclip,(hpatch_size_t)(curCode-codeBegin));
+    return hpatch_TRUE;
+}
+
+hpatch_BOOL _TStreamCacheClip_readDataTo(TStreamCacheClip* sclip,TByte* out_buf,TByte* bufEnd){
+    hpatch_size_t readLen=_TStreamCacheClip_cachedSize(sclip);
+    hpatch_size_t outLen=bufEnd-out_buf;
+    if (readLen>=outLen)
+        readLen=outLen;
+    memcpy(out_buf,&sclip->cacheBuf[sclip->cacheBegin],readLen);
+    sclip->cacheBegin+=readLen;
+    outLen-=readLen;
+    if (outLen){
+        out_buf += readLen;
+        if (outLen<(sclip->cacheEnd>>1)){
+            if (!_TStreamCacheClip_updateCache(sclip)) return _hpatch_FALSE;
+#ifdef __RUN_MEM_SAFE_CHECK
+            if (outLen>_TStreamCacheClip_cachedSize(sclip)) return _hpatch_FALSE;
+#endif
+            return _TStreamCacheClip_readDataTo(sclip, out_buf, bufEnd);
+        }else{
+            if (!sclip->srcStream->read(sclip->srcStream,sclip->streamPos,
+                                        out_buf,bufEnd)) return _hpatch_FALSE;
+            sclip->streamPos+=outLen;
+        }
+    }
+    return hpatch_TRUE;
+}
+
+hpatch_BOOL _TStreamCacheClip_addDataTo(TStreamCacheClip* self,unsigned char* dst,hpatch_size_t addLen){
+    const unsigned char* src=_TStreamCacheClip_readData(self,addLen);
+    if (src==0) return _hpatch_FALSE;
+    addData(dst,src,addLen);
+    return hpatch_TRUE;
+}
+
+    static hpatch_BOOL _decompress_read(const hpatch_TStreamInput* stream,
+                                        const hpatch_StreamPos_t  readFromPos,
+                                        TByte* out_data,TByte* out_data_end){
+        _TDecompressInputStream* self=(_TDecompressInputStream*)stream->streamImport;
+        return self->decompressPlugin->decompress_part(self->decompressHandle,out_data,out_data_end);
+    }
+hpatch_BOOL getStreamClip(TStreamCacheClip* out_clip,_TDecompressInputStream* out_stream,
+                          hpatch_StreamPos_t dataSize,hpatch_StreamPos_t compressedSize,
+                          const hpatch_TStreamInput* stream,hpatch_StreamPos_t* pCurStreamPos,
+                          hpatch_TDecompress* decompressPlugin,TByte* aCache,hpatch_size_t cacheSize){
+    hpatch_StreamPos_t curStreamPos=*pCurStreamPos;
+    if (compressedSize==0){
+#ifdef __RUN_MEM_SAFE_CHECK
+        if ((curStreamPos+dataSize)<curStreamPos) return _hpatch_FALSE;
+        if ((curStreamPos+dataSize)>stream->streamSize) return _hpatch_FALSE;
+#endif
+        if (out_clip)
+            _TStreamCacheClip_init(out_clip,stream,curStreamPos,curStreamPos+dataSize,aCache,cacheSize);
+        curStreamPos+=dataSize;
+    }else{
+#ifdef __RUN_MEM_SAFE_CHECK
+        if ((curStreamPos+compressedSize)<curStreamPos) return _hpatch_FALSE;
+        if ((curStreamPos+compressedSize)>stream->streamSize) return _hpatch_FALSE;
+#endif
+        if (out_clip){
+            out_stream->IInputStream.streamImport=out_stream;
+            out_stream->IInputStream.streamSize=dataSize;
+            out_stream->IInputStream.read=_decompress_read;
+            out_stream->decompressPlugin=decompressPlugin;
+            if (out_stream->decompressHandle==0){
+                out_stream->decompressHandle=decompressPlugin->open(decompressPlugin,dataSize,stream,
+                                                                    curStreamPos,curStreamPos+compressedSize);
+                if (!out_stream->decompressHandle) return _hpatch_FALSE;
+            }else{
+                if (decompressPlugin->reset_code==0) return _hpatch_FALSE;
+                if (!decompressPlugin->reset_code(out_stream->decompressHandle,dataSize,stream,curStreamPos,
+                                                  curStreamPos+compressedSize)) return _hpatch_FALSE;
+            }
+            _TStreamCacheClip_init(out_clip,&out_stream->IInputStream,0,
+                                   out_stream->IInputStream.streamSize,aCache,cacheSize);
+        }
+        curStreamPos+=compressedSize;
+    }
+    *pCurStreamPos=curStreamPos;
+    return hpatch_TRUE;
+}
+
+///////
+
+static hpatch_force_inline hpatch_BOOL __TOutStreamCache_writeStream(_TOutStreamCache* self,const TByte* data,hpatch_size_t dataSize){
+    if (!self->dstStream->write(self->dstStream,self->writeToPos,data,data+dataSize))
+        return _hpatch_FALSE;
+    self->writeToPos+=dataSize;
+    return hpatch_TRUE;
+}
+
+hpatch_BOOL _TOutStreamCache_flush(_TOutStreamCache* self){
+    hpatch_size_t curSize=self->cacheCur;
+    if (curSize>0){
+        if (!__TOutStreamCache_writeStream(self,self->cacheBuf,curSize))
+            return _hpatch_FALSE;
+        self->cacheCur=0;
+    }
+    return hpatch_TRUE;
+}
+
+hpatch_BOOL _TOutStreamCache_write(_TOutStreamCache* self,const TByte* data,hpatch_size_t dataSize){
+    while (dataSize>0) {
+        hpatch_size_t copyLen;
+        hpatch_size_t curSize=self->cacheCur;
+        if ((dataSize>=self->cacheEnd)&&(curSize==0)){
+            return __TOutStreamCache_writeStream(self,data,dataSize);
+        }
+        copyLen=self->cacheEnd-curSize;
+        copyLen=(copyLen<=dataSize)?copyLen:dataSize;
+        memcpy(self->cacheBuf+curSize,data,copyLen);
+        self->cacheCur=curSize+copyLen;
+        data+=copyLen;
+        dataSize-=copyLen;
+        if (self->cacheCur==self->cacheEnd){
+            if (!_TOutStreamCache_flush(self))
+                return _hpatch_FALSE;
+        }
+    }
+    return hpatch_TRUE;
+}
+
+hpatch_BOOL _TOutStreamCache_fill(_TOutStreamCache* self,hpatch_byte fillValue,hpatch_StreamPos_t fillLength){
+    assert(self->cacheBuf);
+    if (self->cacheBuf==0) return _hpatch_FALSE;
+    while (fillLength>0){
+        hpatch_size_t curSize=self->cacheCur;
+        hpatch_size_t runStep=self->cacheEnd-curSize;
+        runStep=(runStep<=fillLength)?runStep:(hpatch_size_t)fillLength;
+        memset(self->cacheBuf+curSize,fillValue,runStep);
+        self->cacheCur=curSize+runStep;
+        fillLength-=runStep;
+        if (self->cacheCur==self->cacheEnd){
+            if (!_TOutStreamCache_flush(self))
+                return _hpatch_FALSE;
+        }
+    }
+    return hpatch_TRUE;
+}
+
+hpatch_BOOL _TOutStreamCache_copyFromStream(_TOutStreamCache* self,const hpatch_TStreamInput* src,
+                                            hpatch_StreamPos_t srcPos,hpatch_StreamPos_t copyLength){
+    assert(self->cacheBuf);
+    if (self->cacheBuf==0) return _hpatch_FALSE;
+    while (copyLength>0){
+        hpatch_size_t curSize=self->cacheCur;
+        hpatch_size_t runStep=self->cacheEnd-curSize;
+        hpatch_byte* buf=self->cacheBuf+curSize;
+        runStep=(runStep<=copyLength)?runStep:(hpatch_size_t)copyLength;
+        if (!src->read(src,srcPos,buf,buf+runStep))
+             return _hpatch_FALSE;
+        srcPos+=runStep;
+        self->cacheCur=curSize+runStep;
+        copyLength-=runStep;
+        if (self->cacheCur==self->cacheEnd){
+            if (!_TOutStreamCache_flush(self))
+                return _hpatch_FALSE;
+        }
+    }
+    return hpatch_TRUE;
+}
+
+hpatch_BOOL _TOutStreamCache_copyFromClip(_TOutStreamCache* self,TStreamCacheClip* src,hpatch_StreamPos_t copyLength){
+    while (copyLength>0){
+        const TByte* data;
+        hpatch_size_t runStep=(src->cacheEnd<=copyLength)?src->cacheEnd:(hpatch_size_t)copyLength;
+        data=_TStreamCacheClip_readData(src,runStep);
+        if (data==0)
+            return _hpatch_FALSE;
+        if (!_TOutStreamCache_write(self,data,runStep))
+            return _hpatch_FALSE;
+        copyLength-=runStep;
+    }
+    return hpatch_TRUE;
+}
+
+hpatch_BOOL _TOutStreamCache_copyFromSelf(_TOutStreamCache* self,hpatch_StreamPos_t aheadLength,hpatch_StreamPos_t copyLength){
+    //      [          writed                 ]
+    //                                        [    cached buf    |        empty buf         ]
+    const hpatch_TStreamInput* src=(const hpatch_TStreamInput*)self->dstStream;
+    hpatch_StreamPos_t srcPos=self->writeToPos+self->cacheCur-aheadLength;
+    if (src->read==0) //can't read
+        return _hpatch_FALSE;
+    if ((aheadLength<1)||(aheadLength>self->writeToPos+self->cacheCur))
+            return _hpatch_FALSE;
+    
+    if (srcPos+copyLength<=self->writeToPos){//copy from stream
+        //    [        copyLength          ]
+__copy_in_stream:
+        return _TOutStreamCache_copyFromStream(self,src,srcPos,copyLength);
+    }else if (srcPos>=self->writeToPos){ //copy in mem
+        //                                      [        copyLength        ]
+__copy_in_mem:
+        while (copyLength>0){
+            hpatch_byte* dstBuf=self->cacheBuf+self->cacheCur;
+            hpatch_byte* srcBuf=dstBuf-(hpatch_size_t)aheadLength;
+            hpatch_size_t runLen=(self->cacheCur+copyLength<=self->cacheEnd)?(hpatch_size_t)copyLength:(self->cacheEnd-self->cacheCur);
+            hpatch_size_t i;
+            for (i=0;i<runLen;i++)
+                dstBuf[i]=srcBuf[i];
+            copyLength-=runLen;
+            self->cacheCur+=runLen;
+            if (self->cacheCur==self->cacheEnd){
+                if (!_TOutStreamCache_flush(self))
+                    return _hpatch_FALSE;
+                runLen=(hpatch_size_t)((aheadLength<=copyLength)?aheadLength:copyLength);
+                memmove(self->cacheBuf,self->cacheBuf+self->cacheEnd-(hpatch_size_t)aheadLength,runLen);
+                self->cacheCur=runLen;
+                copyLength-=runLen;
+            }else{
+                assert(copyLength==0);
+            }
+        }
+        return hpatch_TRUE;
+    }else if (self->writeToPos+self->cacheCur<=srcPos+self->cacheEnd){ 
+        // small data in stream，can as copy in mem
+        hpatch_byte* dstBuf=self->cacheBuf+self->cacheCur;
+        hpatch_size_t runLen=(hpatch_size_t)(self->writeToPos-srcPos);
+        if (!src->read(src,srcPos,dstBuf,dstBuf+runLen))
+            return _hpatch_FALSE;
+        //srcPos+=runLen; //not used
+        copyLength-=runLen;
+        self->cacheCur+=runLen;
+        if (self->cacheCur==self->cacheEnd){
+            while (hpatch_TRUE){
+                if (self->cacheCur==self->cacheEnd){
+                    if (!_TOutStreamCache_flush(self))
+                        return _hpatch_FALSE;
+                }
+                if (copyLength>0){
+                    runLen=(self->cacheEnd<=copyLength)?self->cacheEnd:(hpatch_size_t)copyLength;
+                    //srcPos+=runLen; //not used
+                    copyLength-=runLen;
+                    self->cacheCur=runLen;
+                }else{
+                    return hpatch_TRUE;
+                }
+            }
+        }else{
+            goto __copy_in_mem;
+        }
+    }else{
+        goto __copy_in_stream;
+    }
+}
+
+
+typedef struct _TBytesRle_load_stream{
+    hpatch_StreamPos_t  memCopyLength;
+    hpatch_StreamPos_t  memSetLength;
+    TByte               memSetValue;
+    TStreamCacheClip    ctrlClip;
+    TStreamCacheClip    rleCodeClip;
+} _TBytesRle_load_stream;
+
+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);
+}
+
+hpatch_inline static void memSet_add(TByte* dst,const TByte src,hpatch_size_t length){
+    while (length--) { (*dst++) += src; }
+}
+
+static hpatch_BOOL _TBytesRle_load_stream_mem_add(_TBytesRle_load_stream* loader,
+                                                  hpatch_size_t* _decodeSize,TByte** _out_data){
+    hpatch_size_t  decodeSize=*_decodeSize;
+    TByte* out_data=*_out_data;
+    TStreamCacheClip* rleCodeClip=&loader->rleCodeClip;
+    
+    hpatch_StreamPos_t memSetLength=loader->memSetLength;
+    if (memSetLength!=0){
+        hpatch_size_t memSetStep=((memSetLength<=decodeSize)?(hpatch_size_t)memSetLength:decodeSize);
+        const TByte byteSetValue=loader->memSetValue;
+        if (out_data!=0){
+            if (byteSetValue!=0)
+                memSet_add(out_data,byteSetValue,memSetStep);
+            out_data+=memSetStep;
+        }
+        decodeSize-=memSetStep;
+        loader->memSetLength=memSetLength-memSetStep;
+    }
+    while ((loader->memCopyLength>0)&&(decodeSize>0)) {
+        TByte* rleData;
+        hpatch_size_t decodeStep=rleCodeClip->cacheEnd;
+        if (decodeStep>loader->memCopyLength)
+            decodeStep=(hpatch_size_t)loader->memCopyLength;
+        if (decodeStep>decodeSize)
+            decodeStep=decodeSize;
+        rleData=_TStreamCacheClip_readData(rleCodeClip,decodeStep);
+        if (rleData==0) return _hpatch_FALSE;
+        if (out_data){
+            addData(out_data,rleData,decodeStep);
+            out_data+=decodeStep;
+        }
+        decodeSize-=decodeStep;
+        loader->memCopyLength-=decodeStep;
+    }
+    *_decodeSize=decodeSize;
+    *_out_data=out_data;
+    return hpatch_TRUE;
+}
+
+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));
+}
+
+
+
+#define _clip_unpackUIntWithTagTo(puint,sclip,kTagBit) \
+    { if (!_TStreamCacheClip_unpackUIntWithTag(sclip,puint,kTagBit)) return _hpatch_FALSE; }
+#define _clip_unpackUIntTo(puint,sclip) _clip_unpackUIntWithTagTo(puint,sclip,0)
+
+static hpatch_BOOL _TBytesRle_load_stream_decode_add(_TBytesRle_load_stream* loader,
+                                                     TByte* out_data,hpatch_size_t decodeSize){
+    if (!_TBytesRle_load_stream_mem_add(loader,&decodeSize,&out_data))
+        return _hpatch_FALSE;
+
+    while ((decodeSize>0)&&(!_TStreamCacheClip_isFinish(&loader->ctrlClip))){
+        enum TByteRleType type;
+        hpatch_StreamPos_t length;
+        const TByte* pType=_TStreamCacheClip_accessData(&loader->ctrlClip,1);
+        if (pType==0) return _hpatch_FALSE;
+        type=(enum TByteRleType)((*pType)>>(8-kByteRleType_bit));
+        _clip_unpackUIntWithTagTo(&length,&loader->ctrlClip,kByteRleType_bit);
+        ++length;
+        switch (type){
+            case kByteRleType_rle0:{
+                loader->memSetLength=length;
+                loader->memSetValue=0;
+            }break;
+            case kByteRleType_rle255:{
+                loader->memSetLength=length;
+                loader->memSetValue=255;
+            }break;
+            case kByteRleType_rle:{
+                const TByte* pSetValue=_TStreamCacheClip_readData(&loader->rleCodeClip,1);
+                if (pSetValue==0) return _hpatch_FALSE;
+                loader->memSetValue=*pSetValue;
+                loader->memSetLength=length;
+            }break;
+            case kByteRleType_unrle:{
+                loader->memCopyLength=length;
+            }break;
+        }
+        if (!_TBytesRle_load_stream_mem_add(loader,&decodeSize,&out_data)) return _hpatch_FALSE;
+    }
+
+    if (decodeSize==0)
+        return hpatch_TRUE;
+    else
+        return _hpatch_FALSE;
+}
+
+#define _TBytesRle_load_stream_decode_skip(loader,decodeSize) \
+        _TBytesRle_load_stream_decode_add(loader,0,decodeSize)
+
+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;
+}
+
+typedef struct _TCovers{
+    hpatch_TCovers      ICovers;
+    hpatch_StreamPos_t  coverCount;
+    hpatch_StreamPos_t  oldPosBack;
+    hpatch_StreamPos_t  newPosBack;
+    TStreamCacheClip*   code_inc_oldPosClip;
+    TStreamCacheClip*   code_inc_newPosClip;
+    TStreamCacheClip*   code_lengthsClip;
+    hpatch_BOOL         isOldPosBackNeedAddLength;
+} _TCovers;
+
+static hpatch_StreamPos_t _covers_leaveCoverCount(const hpatch_TCovers* covers){
+    const _TCovers* self=(const _TCovers*)covers;
+    return self->coverCount;
+}
+static hpatch_BOOL _covers_close_nil(hpatch_TCovers* covers){
+    //empty
+    return hpatch_TRUE;
+}
+
+    static hpatch_BOOL _read_sign_pos_byLastPos(TStreamCacheClip* clip,hpatch_StreamPos_t* pLastOldPos){
+        hpatch_StreamPos_t absDelta;
+        const TByte* pSignByte=_TStreamCacheClip_accessData(clip,1);
+        if (!pSignByte) return _hpatch_FALSE;
+        hpatch_BOOL isNeg=((*pSignByte)>>(8-kSignTagBit));
+        _clip_unpackUIntWithTagTo(&absDelta,clip,kSignTagBit);
+        if (isNeg)
+            *pLastOldPos-=absDelta;
+        else
+            *pLastOldPos+=absDelta;
+        return hpatch_TRUE;
+    }
+
+static  hpatch_BOOL _covers_read_cover(hpatch_TCovers* covers,hpatch_TCover* out_cover){
+    _TCovers* self=(_TCovers*)covers;
+    hpatch_StreamPos_t oldPosBack=self->oldPosBack;
+    hpatch_StreamPos_t newPosBack=self->newPosBack;
+    hpatch_StreamPos_t coverCount=self->coverCount;
+    if (coverCount>0)
+        self->coverCount=coverCount-1;
+    else
+        return _hpatch_FALSE;
+    
+    {
+        hpatch_StreamPos_t copyLength,coverLength;
+        if (!_read_sign_pos_byLastPos(self->code_inc_oldPosClip,&oldPosBack))
+            return _hpatch_FALSE;
+        _clip_unpackUIntTo(&copyLength,self->code_inc_newPosClip);
+        _clip_unpackUIntTo(&coverLength,self->code_lengthsClip);
+        newPosBack+=copyLength;
+        
+        out_cover->oldPos=oldPosBack;
+        out_cover->newPos=newPosBack;
+        out_cover->length=coverLength;
+        oldPosBack+=(self->isOldPosBackNeedAddLength)?coverLength:0;
+        newPosBack+=coverLength;
+    }
+    self->oldPosBack=oldPosBack;
+    self->newPosBack=newPosBack;
+    return hpatch_TRUE;
+}
+
+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);
+}
+
+
+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;
+}
+
+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;
+}
+
+static hpatch_BOOL patchByClip(_TOutStreamCache* outCache,
+                               const hpatch_TStreamInput*  oldData,
+                               hpatch_TCovers* covers,
+                               TStreamCacheClip* code_newDataDiffClip,
+                               struct _TBytesRle_load_stream* rle_loader,
+                               TByte* temp_cache,hpatch_size_t cache_size){
+    const hpatch_StreamPos_t newDataSize=_TOutStreamCache_leaveSize(outCache);
+    const hpatch_StreamPos_t oldDataSize=oldData->streamSize;
+    hpatch_StreamPos_t coverCount=covers->leave_cover_count(covers);
+    hpatch_StreamPos_t newPosBack=0;
+    assert(cache_size>=hpatch_kMaxPackedUIntBytes);
+    
+    while (coverCount--){
+        hpatch_TCover cover;
+        if(!covers->read_cover(covers,&cover)) return _hpatch_FALSE;
+#ifdef __RUN_MEM_SAFE_CHECK
+        if (cover.newPos<newPosBack) return _hpatch_FALSE;
+        if (cover.length>(hpatch_StreamPos_t)(newDataSize-cover.newPos)) return _hpatch_FALSE;
+        if (cover.oldPos>oldDataSize) return _hpatch_FALSE;
+        if (cover.length>(hpatch_StreamPos_t)(oldDataSize-cover.oldPos)) return _hpatch_FALSE;
+#endif
+        if (newPosBack<cover.newPos){
+            hpatch_StreamPos_t copyLength=cover.newPos-newPosBack;
+            if (!_TOutStreamCache_copyFromClip(outCache,code_newDataDiffClip,copyLength)) return _hpatch_FALSE;
+            if (!_rle_decode_skip(rle_loader,copyLength)) return _hpatch_FALSE;
+        }
+        if (!_patch_add_old_with_rle(outCache,rle_loader,oldData,cover.oldPos,cover.length,
+                                     temp_cache,cache_size)) return _hpatch_FALSE;
+        newPosBack=cover.newPos+cover.length;
+    }
+    
+    if (newPosBack<newDataSize){
+        hpatch_StreamPos_t copyLength=newDataSize-newPosBack;
+        if (!_TOutStreamCache_copyFromClip(outCache,code_newDataDiffClip,copyLength)) return _hpatch_FALSE;
+        if (!_rle_decode_skip(rle_loader,copyLength)) return _hpatch_FALSE;
+        newPosBack=newDataSize;
+    }
+    if (!_TOutStreamCache_flush(outCache))
+        return _hpatch_FALSE;
+    if (   _TBytesRle_load_stream_isFinish(rle_loader)
+        && covers->is_finish(covers)
+        && _TOutStreamCache_isFinish(outCache)
+        && _TStreamCacheClip_isFinish(code_newDataDiffClip)
+        && (newPosBack==newDataSize) )
+        return hpatch_TRUE;
+    else
+        return _hpatch_FALSE;
+}
+
+
+#define _kCachePatCount 8
+
+#define _cache_alloc(dst,dst_type,memSize,temp_cache,temp_cache_end){   \
+    if ((hpatch_size_t)(temp_cache_end-temp_cache) <   \
+        sizeof(hpatch_StreamPos_t)+(memSize))  return hpatch_FALSE;      \
+    (dst)=(dst_type*)_hpatch_align_upper(temp_cache,sizeof(hpatch_StreamPos_t));\
+    temp_cache=(TByte*)(dst)+(hpatch_size_t)(memSize); \
+}
+
+typedef struct _TPackedCovers{
+    _TCovers            base;
+    TStreamCacheClip    code_inc_oldPosClip;
+    TStreamCacheClip    code_inc_newPosClip;
+    TStreamCacheClip    code_lengthsClip;
+} _TPackedCovers;
+
+typedef struct _THDiffHead{
+    hpatch_StreamPos_t coverCount;
+    hpatch_StreamPos_t lengthSize;
+    hpatch_StreamPos_t inc_newPosSize;
+    hpatch_StreamPos_t inc_oldPosSize;
+    hpatch_StreamPos_t newDataDiffSize;
+    hpatch_StreamPos_t headEndPos;
+    hpatch_StreamPos_t coverEndPos;
+} _THDiffHead;
+
+static hpatch_BOOL read_diff_head(_THDiffHead* out_diffHead,
+                                  const hpatch_TStreamInput* serializedDiff){
+    hpatch_StreamPos_t       diffPos0;
+    const hpatch_StreamPos_t diffPos_end=serializedDiff->streamSize;
+    TByte       temp_cache[hpatch_kStreamCacheSize];
+    TStreamCacheClip  diffHeadClip;
+    _TStreamCacheClip_init(&diffHeadClip,serializedDiff,0,diffPos_end,temp_cache,hpatch_kStreamCacheSize);
+    _clip_unpackUIntTo(&out_diffHead->coverCount,&diffHeadClip);
+    _clip_unpackUIntTo(&out_diffHead->lengthSize,&diffHeadClip);
+    _clip_unpackUIntTo(&out_diffHead->inc_newPosSize,&diffHeadClip);
+    _clip_unpackUIntTo(&out_diffHead->inc_oldPosSize,&diffHeadClip);
+    _clip_unpackUIntTo(&out_diffHead->newDataDiffSize,&diffHeadClip);
+    diffPos0=(hpatch_StreamPos_t)(_TStreamCacheClip_readPosOfSrcStream(&diffHeadClip));
+    out_diffHead->headEndPos=diffPos0;
+#ifdef __RUN_MEM_SAFE_CHECK
+    if (out_diffHead->lengthSize>(hpatch_StreamPos_t)(diffPos_end-diffPos0)) return _hpatch_FALSE;
+#endif
+    diffPos0+=out_diffHead->lengthSize;
+#ifdef __RUN_MEM_SAFE_CHECK
+    if (out_diffHead->inc_newPosSize>(hpatch_StreamPos_t)(diffPos_end-diffPos0)) return _hpatch_FALSE;
+#endif
+    diffPos0+=out_diffHead->inc_newPosSize;
+#ifdef __RUN_MEM_SAFE_CHECK
+    if (out_diffHead->inc_oldPosSize>(hpatch_StreamPos_t)(diffPos_end-diffPos0)) return _hpatch_FALSE;
+#endif
+    diffPos0+=out_diffHead->inc_oldPosSize;
+    out_diffHead->coverEndPos=diffPos0;
+#ifdef __RUN_MEM_SAFE_CHECK
+    if (out_diffHead->newDataDiffSize>(hpatch_StreamPos_t)(diffPos_end-diffPos0)) return _hpatch_FALSE;
+#endif
+    return hpatch_TRUE;
+}
+
+static hpatch_BOOL _packedCovers_open(_TPackedCovers** out_self,
+                                      _THDiffHead* out_diffHead,
+                                      const hpatch_TStreamInput* serializedDiff,
+                                      TByte* temp_cache,TByte* temp_cache_end){
+    hpatch_size_t   cacheSize;
+    _TPackedCovers* self=0;
+    _cache_alloc(self,_TPackedCovers,sizeof(_TPackedCovers),temp_cache,temp_cache_end);
+    cacheSize=(temp_cache_end-temp_cache)/3;
+    {
+        hpatch_StreamPos_t       diffPos0;
+        if (!read_diff_head(out_diffHead,serializedDiff)) return _hpatch_FALSE;
+        diffPos0=out_diffHead->headEndPos;
+        _TStreamCacheClip_init(&self->code_lengthsClip,serializedDiff,diffPos0,
+                               diffPos0+out_diffHead->lengthSize,temp_cache,cacheSize);
+        temp_cache+=cacheSize;
+        diffPos0+=out_diffHead->lengthSize;
+        _TStreamCacheClip_init(&self->code_inc_newPosClip,serializedDiff,diffPos0,
+                               diffPos0+out_diffHead->inc_newPosSize,temp_cache,cacheSize);
+        temp_cache+=cacheSize;
+        diffPos0+=out_diffHead->inc_newPosSize;
+        _TStreamCacheClip_init(&self->code_inc_oldPosClip,serializedDiff,diffPos0,
+                               diffPos0+out_diffHead->inc_oldPosSize,temp_cache,cacheSize);
+    }
+    
+     _covers_init(&self->base,out_diffHead->coverCount,&self->code_inc_oldPosClip,
+                  &self->code_inc_newPosClip,&self->code_lengthsClip,hpatch_FALSE);
+    *out_self=self;
+    return hpatch_TRUE;
+}
+
+static hpatch_BOOL _patch_stream_with_cache(const hpatch_TStreamOutput* out_newData,
+                                            const hpatch_TStreamInput*  oldData,
+                                            const hpatch_TStreamInput*  serializedDiff,
+                                            hpatch_TCovers*  cached_covers,
+                                            TByte*   temp_cache,TByte* temp_cache_end){
+    struct _THDiffHead              diffHead;
+    TStreamCacheClip                code_newDataDiffClip;
+    struct _TBytesRle_load_stream   rle_loader;
+    hpatch_TCovers*                 pcovers=0;
+    hpatch_StreamPos_t       diffPos0;
+    const hpatch_StreamPos_t diffPos_end=serializedDiff->streamSize;
+    const hpatch_size_t cacheSize=(temp_cache_end-temp_cache)/(cached_covers?(_kCachePatCount-3):_kCachePatCount);
+
+    assert(out_newData!=0);
+    assert(out_newData->write!=0);
+    assert(oldData!=0);
+    assert(oldData->read!=0);
+    assert(serializedDiff!=0);
+    assert(serializedDiff->read!=0);
+    
+    //covers
+    if (cached_covers==0){
+        struct _TPackedCovers* packedCovers;
+        if (!_packedCovers_open(&packedCovers,&diffHead,serializedDiff,temp_cache+cacheSize*(_kCachePatCount-3),
+                                temp_cache_end)) return _hpatch_FALSE;
+            pcovers=&packedCovers->base.ICovers; //not need close before return
+    }else{
+        pcovers=cached_covers;
+        if (!read_diff_head(&diffHead,serializedDiff)) return _hpatch_FALSE;
+    }
+    //newDataDiff
+    diffPos0=diffHead.coverEndPos;
+    _TStreamCacheClip_init(&code_newDataDiffClip,serializedDiff,diffPos0,
+                           diffPos0+diffHead.newDataDiffSize,temp_cache,cacheSize);
+    temp_cache+=cacheSize;
+    diffPos0+=diffHead.newDataDiffSize;
+        
+    {//rle
+        hpatch_StreamPos_t rleCtrlSize;
+        hpatch_StreamPos_t rlePos0;
+        TStreamCacheClip*  rleHeadClip=&rle_loader.ctrlClip;//rename, share address
+#ifdef __RUN_MEM_SAFE_CHECK
+        if (cacheSize<hpatch_kMaxPackedUIntBytes) return _hpatch_FALSE;
+#endif
+        _TStreamCacheClip_init(rleHeadClip,serializedDiff,diffPos0,diffPos_end,
+                               temp_cache,hpatch_kMaxPackedUIntBytes);
+        _clip_unpackUIntTo(&rleCtrlSize,rleHeadClip);
+        rlePos0=(hpatch_StreamPos_t)(_TStreamCacheClip_readPosOfSrcStream(rleHeadClip));
+#ifdef __RUN_MEM_SAFE_CHECK
+        if (rleCtrlSize>(hpatch_StreamPos_t)(diffPos_end-rlePos0)) return _hpatch_FALSE;
+#endif
+        _TBytesRle_load_stream_init(&rle_loader);
+        _TStreamCacheClip_init(&rle_loader.ctrlClip,serializedDiff,rlePos0,rlePos0+rleCtrlSize,
+                               temp_cache,cacheSize);
+        temp_cache+=cacheSize;
+        _TStreamCacheClip_init(&rle_loader.rleCodeClip,serializedDiff,rlePos0+rleCtrlSize,diffPos_end,
+                               temp_cache,cacheSize);
+        temp_cache+=cacheSize;
+    }
+    {
+        _TOutStreamCache outCache;
+        _TOutStreamCache_init(&outCache,out_newData,temp_cache,cacheSize);
+        temp_cache+=cacheSize;
+        return patchByClip(&outCache,oldData,pcovers,&code_newDataDiffClip,
+                           &rle_loader,temp_cache,cacheSize);
+    }
+}
+
+
+hpatch_BOOL read_diffz_head(hpatch_compressedDiffInfo* out_diffInfo,_THDiffzHead* out_head,
+                            const hpatch_TStreamInput* compressedDiff){
+    TStreamCacheClip  _diffHeadClip;
+    TStreamCacheClip* diffHeadClip=&_diffHeadClip;
+    TByte             temp_cache[hpatch_kStreamCacheSize];
+    _TStreamCacheClip_init(&_diffHeadClip,compressedDiff,0,compressedDiff->streamSize,
+                           temp_cache,hpatch_kStreamCacheSize);
+    {//type
+        const char* kVersionType="HDIFF13";
+        char* tempType=out_diffInfo->compressType;
+        if (!_TStreamCacheClip_readType_end(diffHeadClip,'&',tempType)) return _hpatch_FALSE;
+        if (0!=strcmp(tempType,kVersionType)) return hpatch_FALSE;
+    }
+    {//read compressType
+        if (!_TStreamCacheClip_readType_end(diffHeadClip,'\0',
+                                            out_diffInfo->compressType)) return _hpatch_FALSE;
+        out_head->typesEndPos=_TStreamCacheClip_readPosOfSrcStream(diffHeadClip);
+    }
+    _clip_unpackUIntTo(&out_diffInfo->newDataSize,diffHeadClip);
+    _clip_unpackUIntTo(&out_diffInfo->oldDataSize,diffHeadClip);
+    _clip_unpackUIntTo(&out_head->coverCount,diffHeadClip);
+    out_head->compressSizeBeginPos=_TStreamCacheClip_readPosOfSrcStream(diffHeadClip);
+    _clip_unpackUIntTo(&out_head->cover_buf_size,diffHeadClip);
+    _clip_unpackUIntTo(&out_head->compress_cover_buf_size,diffHeadClip);
+    _clip_unpackUIntTo(&out_head->rle_ctrlBuf_size,diffHeadClip);
+    _clip_unpackUIntTo(&out_head->compress_rle_ctrlBuf_size,diffHeadClip);
+    _clip_unpackUIntTo(&out_head->rle_codeBuf_size,diffHeadClip);
+    _clip_unpackUIntTo(&out_head->compress_rle_codeBuf_size,diffHeadClip);
+    _clip_unpackUIntTo(&out_head->newDataDiff_size,diffHeadClip);
+    _clip_unpackUIntTo(&out_head->compress_newDataDiff_size,diffHeadClip);
+    out_head->headEndPos=_TStreamCacheClip_readPosOfSrcStream(diffHeadClip);
+    
+    out_diffInfo->compressedCount=((out_head->compress_cover_buf_size)?1:0)
+                                 +((out_head->compress_rle_ctrlBuf_size)?1:0)
+                                 +((out_head->compress_rle_codeBuf_size)?1:0)
+                                 +((out_head->compress_newDataDiff_size)?1:0);
+    if (out_head->compress_cover_buf_size>0)
+        out_head->coverEndPos=out_head->headEndPos+out_head->compress_cover_buf_size;
+    else
+        out_head->coverEndPos=out_head->headEndPos+out_head->cover_buf_size;
+    return hpatch_TRUE;
+}
+
+hpatch_BOOL getCompressedDiffInfo(hpatch_compressedDiffInfo* out_diffInfo,
+                                  const hpatch_TStreamInput* compressedDiff){
+    _THDiffzHead head;
+    assert(out_diffInfo!=0);
+    assert(compressedDiff!=0);
+    assert(compressedDiff->read!=0);
+    return read_diffz_head(out_diffInfo,&head,compressedDiff);
+}
+
+#define _clear_return(exitValue) {  result=exitValue; goto clear; }
+
+#define _kCacheDecCount 6
+
+static
+hpatch_BOOL _patch_decompress_cache(const hpatch_TStreamOutput*  out_newData,
+                                    const hpatch_TStreamInput*   oldData,
+                                    const hpatch_TStreamInput*   compressedDiff,
+                                    hpatch_TDecompress*          decompressPlugin,
+                                    hpatch_TCovers*              cached_covers,
+                                    TByte* temp_cache, TByte* temp_cache_end){
+    TStreamCacheClip              coverClip;
+    TStreamCacheClip              code_newDataDiffClip;
+    struct _TBytesRle_load_stream   rle_loader;
+    _THDiffzHead                head;
+    hpatch_compressedDiffInfo   diffInfo;
+    _TDecompressInputStream     decompressers[4];
+    hpatch_size_t               i;
+    hpatch_StreamPos_t          coverCount;
+    hpatch_BOOL  result=hpatch_TRUE;
+    hpatch_StreamPos_t        diffPos0=0;
+    const hpatch_StreamPos_t  diffPos_end=compressedDiff->streamSize;
+    const hpatch_size_t cacheSize=(temp_cache_end-temp_cache)/(cached_covers?(_kCacheDecCount-1):_kCacheDecCount);
+    if (cacheSize<=hpatch_kMaxPluginTypeLength) return _hpatch_FALSE;
+    assert(out_newData!=0);
+    assert(out_newData->write!=0);
+    assert(oldData!=0);
+    assert(oldData->read!=0);
+    assert(compressedDiff!=0);
+    assert(compressedDiff->read!=0);
+    {//head
+        if (!read_diffz_head(&diffInfo,&head,compressedDiff)) return _hpatch_FALSE;
+        if ((diffInfo.oldDataSize!=oldData->streamSize)
+            ||(diffInfo.newDataSize!=out_newData->streamSize)) return _hpatch_FALSE;
+            
+        if ((decompressPlugin==0)&&(diffInfo.compressedCount!=0)) return _hpatch_FALSE;
+        if ((decompressPlugin)&&(diffInfo.compressedCount>0))
+            if (!decompressPlugin->is_can_open(diffInfo.compressType)) return _hpatch_FALSE;
+        diffPos0=head.headEndPos;
+    }
+    
+    for (i=0;i<sizeof(decompressers)/sizeof(_TDecompressInputStream);++i)
+        decompressers[i].decompressHandle=0;
+    _TBytesRle_load_stream_init(&rle_loader);
+    
+    if (cached_covers){
+        diffPos0=head.coverEndPos;
+    }else{
+        if (!getStreamClip(&coverClip,&decompressers[0],
+                           head.cover_buf_size,head.compress_cover_buf_size,compressedDiff,&diffPos0,
+                           decompressPlugin,temp_cache+cacheSize*(_kCacheDecCount-1),cacheSize)) _clear_return(_hpatch_FALSE);
+    }
+    if (!getStreamClip(&rle_loader.ctrlClip,&decompressers[1],
+                       head.rle_ctrlBuf_size,head.compress_rle_ctrlBuf_size,compressedDiff,&diffPos0,
+                       decompressPlugin,temp_cache,cacheSize)) _clear_return(_hpatch_FALSE);
+    temp_cache+=cacheSize;
+    if (!getStreamClip(&rle_loader.rleCodeClip,&decompressers[2],
+                       head.rle_codeBuf_size,head.compress_rle_codeBuf_size,compressedDiff,&diffPos0,
+                       decompressPlugin,temp_cache,cacheSize)) _clear_return(_hpatch_FALSE);
+    temp_cache+=cacheSize;
+    if (!getStreamClip(&code_newDataDiffClip,&decompressers[3],
+                       head.newDataDiff_size,head.compress_newDataDiff_size,compressedDiff,&diffPos0,
+                       decompressPlugin,temp_cache,cacheSize)) _clear_return(_hpatch_FALSE);
+    temp_cache+=cacheSize;
+#ifdef __RUN_MEM_SAFE_CHECK
+    if (diffPos0!=diffPos_end) _clear_return(_hpatch_FALSE);
+#endif
+    
+    coverCount=head.coverCount;
+    {
+        _TCovers         covers;
+        hpatch_TCovers*  pcovers=0;
+        _TOutStreamCache outCache;
+        _TOutStreamCache_init(&outCache,out_newData,temp_cache,cacheSize);
+        temp_cache+=cacheSize;
+        if (cached_covers){
+            pcovers=cached_covers;
+        }else{
+            _covers_init(&covers,coverCount,&coverClip,&coverClip,&coverClip,hpatch_TRUE);
+            pcovers=&covers.ICovers;  //not need close before return
+        }
+        result=patchByClip(&outCache,oldData,pcovers,&code_newDataDiffClip,&rle_loader,
+                           temp_cache,cacheSize);
+        //if ((pcovers!=cached_covers)&&(!pcovers->close(pcovers))) result=_hpatch_FALSE;
+    }
+clear:
+    for (i=0;i<sizeof(decompressers)/sizeof(_TDecompressInputStream);++i) {
+        if (decompressers[i].decompressHandle){
+            if (!decompressPlugin->close(decompressPlugin,decompressers[i].decompressHandle))
+                result=_hpatch_FALSE;
+            decompressers[i].decompressHandle=0;
+        }
+    }
+    return result;
+}
+
+
+hpatch_inline static hpatch_BOOL _cache_load_all(const hpatch_TStreamInput* data,
+                                                 TByte* cache,TByte* cache_end){
+    assert((hpatch_size_t)(cache_end-cache)==data->streamSize);
+    return data->read(data,0,cache,cache_end);
+}
+
+typedef struct _TCompressedCovers{
+    _TCovers                base;
+    TStreamCacheClip        coverClip;
+    _TDecompressInputStream decompresser;
+} _TCompressedCovers;
+
+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;
+}
+
+static hpatch_BOOL _compressedCovers_open(_TCompressedCovers** out_self,
+                                          hpatch_compressedDiffInfo* out_diffInfo,
+                                          const hpatch_TStreamInput* compressedDiff,
+                                          hpatch_TDecompress* decompressPlugin,
+                                          TByte* temp_cache,TByte* temp_cache_end){
+    _THDiffzHead    head;
+    hpatch_StreamPos_t  diffPos0=0;
+    _TCompressedCovers* self=0;
+    _cache_alloc(self,_TCompressedCovers,sizeof(_TCompressedCovers),temp_cache,temp_cache_end);
+    if (!read_diffz_head(out_diffInfo,&head,compressedDiff)) return _hpatch_FALSE;
+    diffPos0=head.headEndPos;
+    if (head.compress_cover_buf_size>0){
+        if (decompressPlugin==0) return _hpatch_FALSE;
+        if (!decompressPlugin->is_can_open(out_diffInfo->compressType)) return _hpatch_FALSE;
+    }
+    
+    _covers_init(&self->base,head.coverCount,&self->coverClip,
+                 &self->coverClip,&self->coverClip,hpatch_TRUE);
+    self->base.ICovers.close=_compressedCovers_close;
+    memset(&self->decompresser,0, sizeof(self->decompresser));
+    if (!getStreamClip(&self->coverClip,&self->decompresser,
+                       head.cover_buf_size,head.compress_cover_buf_size,
+                       compressedDiff,&diffPos0,decompressPlugin,
+                       temp_cache,temp_cache_end-temp_cache)) {
+        return _hpatch_FALSE;
+    };
+    *out_self=self;
+    return hpatch_TRUE;
+}
+
+
+//kMinSkipSpaceLen: skip space of length seekTime*speed if time-efficient, otherwise sequential access;
+//  SSD: 4K-64K   HHD: 1M
+const hpatch_size_t kMinSkipSpaceLen =1024*256; //default 256k
+
+#if (_IS_NEED_CACHE_OLD_BY_COVERS)
+
+typedef struct _TArrayCovers{
+    hpatch_TCovers  ICovers;
+    void*           pCCovers;
+    hpatch_size_t   coverCount;
+    hpatch_size_t   cur_index;
+    hpatch_BOOL     is32;
+} _TArrayCovers;
+
+
+typedef struct hpatch_TCCover32{
+    hpatch_uint32_t oldPos;
+    hpatch_uint32_t newPos;
+    hpatch_uint32_t length;
+    hpatch_uint32_t cachePos; //Consider moving to temporary memory and releasing after use? Logic would be more complex;
+} hpatch_TCCover32;
+
+typedef struct hpatch_TCCover64{
+    hpatch_StreamPos_t oldPos;
+    hpatch_StreamPos_t newPos;
+    hpatch_StreamPos_t length;
+    hpatch_StreamPos_t cachePos;
+} hpatch_TCCover64;
+
+#define _arrayCovers_get(self,i,item) (((self)->is32)? \
+    ((const hpatch_uint32_t*)(self)->pCCovers)[(i)*4+(item)]:\
+    ((const hpatch_StreamPos_t*)(self)->pCCovers)[(i)*4+(item)])
+#define _arrayCovers_get_oldPos(self,i)   _arrayCovers_get(self,i,0)
+#define _arrayCovers_get_len(self,i)      _arrayCovers_get(self,i,2)
+#define _arrayCovers_get_cachePos(self,i) _arrayCovers_get(self,i,3)
+
+#define _arrayCovers_set(self,i,item,v) { if ((self)->is32){ \
+    ((hpatch_uint32_t*)(self)->pCCovers)[(i)*4+(item)]=(hpatch_uint32_t)(v); }else{ \
+    ((hpatch_StreamPos_t*)(self)->pCCovers)[(i)*4+(item)]=(v); } }
+#define _arrayCovers_set_cachePos(self,i,v) _arrayCovers_set(self,i,3,v)
+
+hpatch_inline static hpatch_StreamPos_t arrayCovers_memSize(hpatch_StreamPos_t coverCount,hpatch_BOOL is32){
+    return coverCount*(is32?sizeof(hpatch_TCCover32):sizeof(hpatch_TCCover64));
+}
+
+static hpatch_BOOL _arrayCovers_is_finish(const hpatch_TCovers* covers){
+    const _TArrayCovers* self=(const _TArrayCovers*)covers;
+    return (self->coverCount==self->cur_index);
+}
+static hpatch_StreamPos_t _arrayCovers_leaveCoverCount(const hpatch_TCovers* covers){
+    const _TArrayCovers* self=(const _TArrayCovers*)covers;
+    return self->coverCount-self->cur_index;
+}
+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;
+    }
+}
+
+static hpatch_force_inline void _arrayCovers_push_cover(_TArrayCovers* self,const hpatch_TCover* cover){
+    hpatch_size_t i=self->coverCount;
+    if (self->is32){
+        hpatch_TCCover32* pCover=((hpatch_TCCover32*)self->pCCovers)+i;
+        pCover->oldPos=(hpatch_uint32_t)cover->oldPos;
+        pCover->newPos=(hpatch_uint32_t)cover->newPos;
+        pCover->length=(hpatch_uint32_t)cover->length;
+    }else{
+        hpatch_TCCover64* pCover=((hpatch_TCCover64*)self->pCCovers)+i;
+        pCover->oldPos=cover->oldPos;
+        pCover->newPos=cover->newPos;
+        pCover->length=cover->length;
+    }
+    self->coverCount=i+1;
+}
+
+static hpatch_BOOL _arrayCovers_load(_TArrayCovers** out_self,hpatch_TCovers* src_covers,
+                                     hpatch_BOOL isUsedCover32,hpatch_BOOL* out_isReadError,
+                                     TByte** ptemp_cache,TByte* temp_cache_end){
+    TByte* temp_cache=*ptemp_cache;
+    hpatch_StreamPos_t _coverCount=src_covers->leave_cover_count(src_covers);
+    hpatch_StreamPos_t memSize=arrayCovers_memSize(_coverCount,isUsedCover32);
+    hpatch_size_t i;
+    void*  pCovers;
+    _TArrayCovers* self=0;
+    hpatch_size_t coverCount=(hpatch_size_t)_coverCount;
+    
+    *out_isReadError=hpatch_FALSE;
+    if (coverCount!=_coverCount) return hpatch_FALSE;
+    
+    _cache_alloc(self,_TArrayCovers,sizeof(_TArrayCovers),temp_cache,temp_cache_end);
+    _cache_alloc(pCovers,void,memSize,temp_cache,temp_cache_end);
+    if (isUsedCover32){
+        hpatch_TCCover32* pdst=(hpatch_TCCover32*)pCovers;
+        for (i=0;i<coverCount;++i,++pdst) {
+            hpatch_TCover cover;
+            if (!src_covers->read_cover(src_covers,&cover))
+                { *out_isReadError=hpatch_TRUE; return _hpatch_FALSE; }
+            pdst->oldPos=(hpatch_uint32_t)cover.oldPos;
+            pdst->newPos=(hpatch_uint32_t)cover.newPos;
+            pdst->length=(hpatch_uint32_t)cover.length;
+        }
+    }else{
+        hpatch_TCCover64* pdst=(hpatch_TCCover64*)pCovers;
+        for (i=0;i<coverCount;++i,++pdst) {
+            if (!src_covers->read_cover(src_covers,(hpatch_TCover*)pdst))
+                { *out_isReadError=hpatch_TRUE; return _hpatch_FALSE; }
+        }
+    }
+    if (!src_covers->is_finish(src_covers))
+        { *out_isReadError=hpatch_TRUE; return _hpatch_FALSE; }
+
+    self->pCCovers=pCovers;
+    self->is32=isUsedCover32;
+    self->coverCount=coverCount;
+    self->cur_index=0;
+    self->ICovers.close=_covers_close_nil;
+    self->ICovers.is_finish=_arrayCovers_is_finish;
+    self->ICovers.leave_cover_count=_arrayCovers_leaveCoverCount;
+    self->ICovers.read_cover=_arrayCovers_read_cover;
+    *out_self=self;
+    *ptemp_cache=temp_cache;
+    return hpatch_TRUE;
+}
+
+#define _arrayCovers_comp(_uint_t,_x,_y,item){ \
+    _uint_t x=((const _uint_t*)_x)[item]; \
+    _uint_t y=((const _uint_t*)_y)[item]; \
+    return (x<y)?(-1):((x>y)?1:0); \
+}
+#ifdef _MSC_VER
+#   define __CALL_BACK_C    __cdecl
+#else
+#   define __CALL_BACK_C
+#endif
+static hpatch_int __CALL_BACK_C _arrayCovers_comp_by_old_32(const void* _x, const void *_y){
+    _arrayCovers_comp(hpatch_uint32_t,_x,_y,0);
+}
+static hpatch_int __CALL_BACK_C _arrayCovers_comp_by_old(const void* _x, const void *_y){
+    _arrayCovers_comp(hpatch_StreamPos_t,_x,_y,0);
+}
+static hpatch_int __CALL_BACK_C _arrayCovers_comp_by_new_32(const void* _x, const void *_y){
+    _arrayCovers_comp(hpatch_uint32_t,_x,_y,1);
+}
+static hpatch_int __CALL_BACK_C _arrayCovers_comp_by_new(const void* _x, const void *_y){
+    _arrayCovers_comp(hpatch_StreamPos_t,_x,_y,1);
+}
+static hpatch_int __CALL_BACK_C _arrayCovers_comp_by_len_32(const void* _x, const void *_y){
+    _arrayCovers_comp(hpatch_uint32_t,_x,_y,2);
+}
+static hpatch_int __CALL_BACK_C _arrayCovers_comp_by_len(const void* _x, const void *_y){
+    _arrayCovers_comp(hpatch_StreamPos_t,_x,_y,2);
+}
+
+hpatch_force_inline
+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);
+}
+hpatch_force_inline
+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);
+}
+hpatch_force_inline
+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);
+}
+
+static hpatch_StreamPos_t _getCacheSumLen(const _TArrayCovers* src_covers,hpatch_StreamPos_t maxCachedLen){
+    const hpatch_size_t coverCount=src_covers->coverCount;
+    hpatch_StreamPos_t  sumLen=0;
+    hpatch_size_t i;
+    for (i=0; i<coverCount;++i) {
+        hpatch_StreamPos_t mlen=_arrayCovers_get_len(src_covers,i);
+        sumLen+=(mlen<=maxCachedLen)?mlen:0;
+    }
+    return sumLen;
+}
+
+static hpatch_size_t _getMaxCachedLen(_TArrayCovers* arrayCovers,hpatch_size_t cacheSize){
+    const hpatch_size_t kMaxCachedLen  =(~((hpatch_size_t)0))/2;//max allowed length for a single cached data item;
+    hpatch_StreamPos_t mlen=0;
+    hpatch_StreamPos_t sum=0;
+    const hpatch_size_t coverCount=arrayCovers->coverCount;
+    hpatch_size_t i;
+    _arrayCovers_sort_by_len(arrayCovers);
+    
+    for (i=0; i<coverCount;++i) {
+        mlen=_arrayCovers_get_len(arrayCovers,i);
+        sum+=mlen;
+        if (sum<=cacheSize){
+            continue;
+        }else{
+            --mlen;
+            break;
+        }
+    }
+    if (mlen>kMaxCachedLen)
+        mlen=kMaxCachedLen;
+    _arrayCovers_sort_by_new(arrayCovers);
+    return (hpatch_size_t)mlen;
+}
+
+static hpatch_size_t _set_cache_pos(_TArrayCovers* covers,hpatch_size_t maxCachedLen,
+                                    hpatch_StreamPos_t* poldPosBegin,hpatch_StreamPos_t* poldPosEnd,
+                                    hpatch_size_t kMinCacheCoverCount){
+    const hpatch_size_t coverCount=covers->coverCount;
+    hpatch_StreamPos_t oldPosBegin=hpatch_kNullStreamPos;
+    hpatch_StreamPos_t oldPosEnd=0;
+    hpatch_size_t cacheCoverCount=0;
+    hpatch_size_t sum=0;//result
+    hpatch_size_t i;
+    for (i=0; i<coverCount;++i) {
+        hpatch_StreamPos_t clen=_arrayCovers_get_len(covers,i);
+        if (clen<=maxCachedLen){
+            hpatch_StreamPos_t oldPos;
+            _arrayCovers_set_cachePos(covers,i,sum);
+            sum+=(hpatch_size_t)clen;
+            ++cacheCoverCount;
+            
+            oldPos=_arrayCovers_get_oldPos(covers,i);
+            if (oldPos<oldPosBegin) oldPosBegin=oldPos;
+            if (oldPos+clen>oldPosEnd) oldPosEnd=oldPos+clen;
+        }
+    }
+    if (cacheCoverCount<kMinCacheCoverCount)
+        return 0;//fail
+    *poldPosBegin=oldPosBegin;
+    *poldPosEnd=oldPosEnd;
+    return sum;
+}
+
+//a simple caching strategy:
+//  1. select a batch of shortest cover lines to cache based on buffer size limit;
+//  2. sequentially access the oldData file once to fill these caches;
+//  3. skip large intermediate regions that are useless for caching during sequential access;
+
+static hpatch_BOOL _cache_old_load(const hpatch_TStreamInput*oldData,
+                                   hpatch_StreamPos_t oldPos,hpatch_StreamPos_t oldPosAllEnd,
+                                   _TArrayCovers* arrayCovers,hpatch_size_t maxCachedLen,hpatch_size_t sumCacheLen,
+                                   TByte* old_cache,TByte* old_cache_end,TByte* cache_buf_end){
+    const hpatch_size_t kAccessPageSize=4096;//disk page-aligned access (affects only speed, but impact is minimal);
+    hpatch_BOOL result=hpatch_TRUE;
+    hpatch_size_t cur_i=0,i;
+    const hpatch_size_t coverCount=arrayCovers->coverCount;
+    TByte* cache_buf=old_cache_end;
+    assert((hpatch_size_t)(old_cache_end-old_cache)>=sumCacheLen);
+    
+    if ((hpatch_size_t)(cache_buf_end-cache_buf)>=kAccessPageSize*2){
+        cache_buf=(TByte*)_hpatch_align_upper(cache_buf,kAccessPageSize);
+        if ((hpatch_size_t)(cache_buf_end-cache_buf)>=(kMinSkipSpaceLen>>1))
+            cache_buf_end=cache_buf+(kMinSkipSpaceLen>>1);
+        else
+            cache_buf_end=(TByte*)_hpatch_align_lower(cache_buf_end,kAccessPageSize);
+    }
+    oldPos=_hpatch_align_type_lower(hpatch_StreamPos_t,oldPos,kAccessPageSize);
+    if (oldPos<kMinSkipSpaceLen) oldPos=0;
+    
+    _arrayCovers_sort_by_old(arrayCovers);
+    while ((oldPos<oldPosAllEnd)&&(cur_i<coverCount)) {
+        hpatch_StreamPos_t oldPosEnd;
+        hpatch_size_t readLen=(cache_buf_end-cache_buf);
+        if (readLen>(oldPosAllEnd-oldPos)) readLen=(hpatch_size_t)(oldPosAllEnd-oldPos);
+        if (!oldData->read(oldData,oldPos,cache_buf,
+                           cache_buf+readLen)) { result=_hpatch_FALSE; break; } //error
+        oldPosEnd=oldPos+readLen;
+        for (i=cur_i;i<coverCount;++i){
+            hpatch_StreamPos_t ioldPos,ioldPosEnd;
+            hpatch_StreamPos_t ilen=_arrayCovers_get_len(arrayCovers,i);
+            if (ilen>maxCachedLen){//cover line too long to cache, proceed to next cover line;
+                if (i==cur_i)
+                    ++cur_i;
+                continue;
+            }
+            ioldPos=_arrayCovers_get_oldPos(arrayCovers,i);
+            ioldPosEnd=ioldPos+ilen;
+            if (ioldPosEnd>oldPos){
+                //        [oldPos                  oldPosEnd]
+                //                           ioldPosEnd]----or----]
+                if (ioldPos<oldPosEnd){//intersection exists, needs cache
+                //  [----or----[ioldPos      ioldPosEnd]----or----]
+                    hpatch_StreamPos_t from;
+                    hpatch_size_t      copyLen;
+                    hpatch_StreamPos_t dstPos=_arrayCovers_get_cachePos(arrayCovers,i);
+                    //assert(dstPos<=(hpatch_size_t)(old_cache_end-old_cache));
+                    if (ioldPos>=oldPos){
+                //             [ioldPos      ioldPosEnd]----or----]
+                        from=ioldPos;
+                    }else{
+                //  [ioldPos                 ioldPosEnd]----or----]
+                        from=oldPos;
+                        dstPos+=(oldPos-ioldPos);
+                    }
+                    copyLen=(hpatch_size_t)(((ioldPosEnd<=oldPosEnd)?ioldPosEnd:oldPosEnd)-from);
+                    //assert(dstPos+copyLen<=(hpatch_size_t)(old_cache_end-old_cache));
+                    //assert(sumCacheLen>=copyLen);
+                    memcpy(old_cache+(hpatch_size_t)dstPos,cache_buf+(from-oldPos),copyLen);
+                    sumCacheLen-=copyLen;
+                    if ((i==cur_i)&&(oldPosEnd>=ioldPosEnd))
+                        ++cur_i;
+                }else{//no more intersections with current data for following cover lines, move to next data block;
+                //  [oldPos     oldPosEnd]
+                //                        [ioldPos      ioldPosEnd]
+                    if ((i==cur_i)&&(ioldPos-oldPosEnd>=kMinSkipSpaceLen))
+                        oldPosEnd=_hpatch_align_type_lower(hpatch_StreamPos_t,ioldPos,kAccessPageSize);
+                    break;
+                }
+            }else{//current cover line is behind current data, proceed to next cover line;
+                //                        [oldPos     oldPosEnd]
+                // [ioldPos    ioldPosEnd]
+                if (i==cur_i)
+                    ++cur_i;
+            }
+        }
+        oldPos=oldPosEnd;
+    }
+    _arrayCovers_sort_by_new(arrayCovers);
+    assert(sumCacheLen==0);
+    return result;
+}
+
+typedef struct _cache_old_TStreamInput{
+    _TArrayCovers       arrayCovers;
+    hpatch_BOOL         isInHitCache;
+    hpatch_size_t       maxCachedLen;
+    hpatch_StreamPos_t  readFromPos;
+    hpatch_StreamPos_t  readFromPosEnd;
+    const TByte*        caches;
+    const TByte*        cachesEnd;
+    const hpatch_TStreamInput* oldData;
+    void*               _cacheImport;
+    hpatch_BOOL         (*_doUpdateCacheCovers)(void* _cacheImport);
+} _cache_old_TStreamInput;
+
+static hpatch_BOOL _cache_old_StreamInput_read(const hpatch_TStreamInput* stream,
+                                               hpatch_StreamPos_t readFromPos,
+                                               unsigned char* out_data,unsigned char* out_data_end){
+    _cache_old_TStreamInput* self=(_cache_old_TStreamInput*)stream->streamImport;
+    hpatch_size_t readLen;
+    hpatch_StreamPos_t dataLen=(hpatch_size_t)(self->readFromPosEnd-self->readFromPos);
+    if (dataLen==0){//next cover
+        hpatch_StreamPos_t oldPos;
+        hpatch_size_t i=self->arrayCovers.cur_index++;
+        if (i>=self->arrayCovers.coverCount){
+            if ((self->_doUpdateCacheCovers)&&(self->_doUpdateCacheCovers(self->_cacheImport))){
+                i=self->arrayCovers.cur_index++;
+                if (i>=self->arrayCovers.coverCount)
+                    return _hpatch_FALSE;//update error;
+            }else
+                return _hpatch_FALSE;//error;
+        }
+        oldPos=_arrayCovers_get_oldPos(&self->arrayCovers,i);
+        dataLen=_arrayCovers_get_len(&self->arrayCovers,i);
+        self->isInHitCache=(dataLen<=self->maxCachedLen);
+        self->readFromPos=oldPos;
+        self->readFromPosEnd=oldPos+dataLen;
+    }
+    readLen=out_data_end-out_data;
+    if ((readLen>dataLen)||(self->readFromPos!=readFromPos)) return _hpatch_FALSE; //error
+    self->readFromPos=readFromPos+readLen;
+    if (self->isInHitCache){
+        assert(readLen<=(hpatch_size_t)(self->cachesEnd-self->caches));
+        memcpy(out_data,self->caches,readLen);
+        self->caches+=readLen;
+        return hpatch_TRUE;
+    }else{
+        return self->oldData->read(self->oldData,readFromPos,out_data,out_data_end);
+    }
+}
+
+static hpatch_BOOL _cache_old(hpatch_TStreamInput** out_cachedOld,const hpatch_TStreamInput* oldData,
+                              _TArrayCovers* arrayCovers,hpatch_BOOL* out_isReadError,
+                              TByte* temp_cache,TByte** ptemp_cache_end,TByte* cache_buf_end){
+    _cache_old_TStreamInput* self;
+    TByte* temp_cache_end=*ptemp_cache_end;
+    hpatch_StreamPos_t oldPosBegin;
+    hpatch_StreamPos_t oldPosEnd;
+    hpatch_size_t      sumCacheLen;
+    hpatch_size_t      maxCachedLen;
+    const hpatch_size_t kMinCacheCoverCount=arrayCovers->coverCount/8+1; //control min cache count, otherwise caching becomes ineffective;
+    *out_isReadError=hpatch_FALSE;
+    _cache_alloc(*out_cachedOld,hpatch_TStreamInput,sizeof(hpatch_TStreamInput),
+                 temp_cache,temp_cache_end);
+    _cache_alloc(self,_cache_old_TStreamInput,sizeof(_cache_old_TStreamInput),
+                 temp_cache,temp_cache_end);
+    
+    maxCachedLen=_getMaxCachedLen(arrayCovers,temp_cache_end-temp_cache);
+    if (maxCachedLen==0) return hpatch_FALSE;
+    sumCacheLen=_set_cache_pos(arrayCovers,maxCachedLen,&oldPosBegin,&oldPosEnd,kMinCacheCoverCount);
+    if (sumCacheLen==0) return hpatch_FALSE;
+    temp_cache_end=temp_cache+sumCacheLen;
+    
+    if (!_cache_old_load(oldData,oldPosBegin,oldPosEnd,arrayCovers,maxCachedLen,sumCacheLen,
+                         temp_cache,temp_cache_end,cache_buf_end))
+        { *out_isReadError=hpatch_TRUE; return _hpatch_FALSE; }
+    
+    {//out
+        self->arrayCovers=*arrayCovers;
+        self->arrayCovers.cur_index=0;
+        self->isInHitCache=hpatch_FALSE;
+        self->maxCachedLen=maxCachedLen;
+        self->caches=temp_cache;
+        self->cachesEnd=temp_cache_end;
+        self->readFromPos=0;
+        self->readFromPosEnd=0;
+        self->oldData=oldData;
+        (*out_cachedOld)->streamImport=self;
+        (*out_cachedOld)->streamSize=oldData->streamSize;
+        (*out_cachedOld)->read=_cache_old_StreamInput_read;
+        *ptemp_cache_end=temp_cache_end;
+    }
+    return hpatch_TRUE;
+}
+
+#endif //_IS_NEED_CACHE_OLD_BY_COVERS
+
+#if (_IS_NEED_CACHE_OLD_ALL)
+hpatch_BOOL _patch_cache_all_old(const hpatch_TStreamInput** poldData,size_t kMinTempCacheSize,
+                                 TByte** ptemp_cache,TByte** ptemp_cache_end,hpatch_BOOL* out_isReadError){
+    const hpatch_TStreamInput* oldData=*poldData;
+    TByte* temp_cache=*ptemp_cache;
+    TByte* temp_cache_end=*ptemp_cache_end;
+    *out_isReadError=hpatch_FALSE;
+    if (_patch_is_can_cache_all_old(oldData->streamSize,kMinTempCacheSize,temp_cache_end-temp_cache)){//load all oldData
+        hpatch_TStreamInput* replace_oldData=0;
+        _cache_alloc(replace_oldData,hpatch_TStreamInput,sizeof(hpatch_TStreamInput),
+                     temp_cache,temp_cache_end);
+        if (!_cache_load_all(oldData,temp_cache_end-oldData->streamSize,
+                             temp_cache_end)){ *out_isReadError=hpatch_TRUE; return _hpatch_FALSE; }
+        
+        mem_as_hStreamInput(replace_oldData,temp_cache_end-oldData->streamSize,temp_cache_end);
+        temp_cache_end-=oldData->streamSize;
+        // [          patch cache            |       oldData cache     ]
+        // [ (cacheSize-oldData->streamSize) |  (oldData->streamSize)  ]
+        *poldData=replace_oldData;
+        *ptemp_cache=temp_cache;
+        *ptemp_cache_end=temp_cache_end;
+        return hpatch_TRUE;
+    }
+    return hpatch_FALSE;
+}
+#endif //_IS_NEED_CACHE_OLD_ALL
+
+static hpatch_BOOL _patch_cache(hpatch_TCovers** out_covers,
+                                const hpatch_TStreamInput** poldData,hpatch_StreamPos_t newDataSize,
+                                const hpatch_TStreamInput*  diffData,hpatch_BOOL isCompressedDiff,
+                                hpatch_TDecompress* decompressPlugin,size_t kCacheCount,
+                                TByte** ptemp_cache,TByte** ptemp_cache_end,hpatch_BOOL* out_isReadError){
+    const hpatch_TStreamInput* oldData=*poldData;
+#if (_IS_NEED_CACHE_OLD_BY_COVERS)
+    const hpatch_size_t kBestACacheSize=hpatch_kFileIOBufBetterSize;   //optimal hpatch_kStreamCacheSize value when sufficient memory is available;
+    const hpatch_size_t _minActiveSize=(1<<20)*3+kBestACacheSize*kCacheCount*2;
+    const hpatch_StreamPos_t _betterActiveSize=oldData->streamSize/16+kBestACacheSize*kCacheCount*2;
+    const hpatch_size_t kActiveCacheOldMemorySize = //min memory threshold for attempting to activate CacheOld functionality;
+                (_minActiveSize>_betterActiveSize)?_minActiveSize:(hpatch_size_t)_betterActiveSize;
+#endif //_IS_NEED_CACHE_OLD_BY_COVERS
+    TByte* temp_cache=*ptemp_cache;
+    TByte* temp_cache_end=*ptemp_cache_end;
+    *out_covers=0;
+    if (_patch_cache_all_old(poldData,kCacheCount*hpatch_kStreamCacheSize,ptemp_cache,ptemp_cache_end,out_isReadError))
+        return hpatch_TRUE;//cache all oldData
+    if (*out_isReadError) return hpatch_FALSE;
+#if (_IS_NEED_CACHE_OLD_BY_COVERS)
+    if ((hpatch_size_t)(temp_cache_end-temp_cache)>=kActiveCacheOldMemorySize) {// try cache part of oldData
+        hpatch_BOOL         isUsedCover32;
+        TByte*              temp_cache_end_back=temp_cache_end;
+        _TArrayCovers*      arrayCovers=0;
+        assert((hpatch_size_t)(temp_cache_end-temp_cache)>kBestACacheSize*kCacheCount);
+        assert(kBestACacheSize>sizeof(_TCompressedCovers)+sizeof(_TPackedCovers));
+        if (isCompressedDiff){
+            hpatch_compressedDiffInfo diffInfo;
+            _TCompressedCovers* compressedCovers=0;
+            if (!_compressedCovers_open(&compressedCovers,&diffInfo,diffData,decompressPlugin,
+                                        temp_cache_end-kBestACacheSize-sizeof(_TCompressedCovers),temp_cache_end))
+                { *out_isReadError=hpatch_TRUE; return _hpatch_FALSE; }
+            if ((oldData->streamSize!=diffInfo.oldDataSize)||(newDataSize!=diffInfo.newDataSize))
+                { *out_isReadError=hpatch_TRUE; return _hpatch_FALSE; }
+            temp_cache_end-=kBestACacheSize+sizeof(_TCompressedCovers);
+            // [                       ...                                 |   compressedCovers cache   ]
+            // [           (cacheSize-kBestACacheSize)                     |      (kBestACacheSize)     ]
+            *out_covers=&compressedCovers->base.ICovers;
+            isUsedCover32=(diffInfo.oldDataSize|diffInfo.newDataSize)<((hpatch_uint64_t)1<<32);
+        }else{
+            _TPackedCovers* packedCovers=0;
+            _THDiffHead     diffHead;
+            hpatch_StreamPos_t oldDataSize=oldData->streamSize;
+            if (!_packedCovers_open(&packedCovers,&diffHead,diffData,
+                                    temp_cache_end-kBestACacheSize*3-sizeof(_TPackedCovers),temp_cache_end))
+                { *out_isReadError=hpatch_TRUE; return _hpatch_FALSE; }
+            temp_cache_end-=kBestACacheSize*3+sizeof(_TPackedCovers);
+            // [                       ...                                 |     packedCovers cache     ]
+            // [          (cacheSize-kBestACacheSize*3)                    |    (kBestACacheSize*3)     ]
+            *out_covers=&packedCovers->base.ICovers;
+            isUsedCover32=(oldDataSize|newDataSize)<((hpatch_uint64_t)1<<32);
+        }
+        
+        if (!_arrayCovers_load(&arrayCovers,*out_covers,isUsedCover32,
+                               out_isReadError,&temp_cache,temp_cache_end-kBestACacheSize)){
+            if (*out_isReadError) return _hpatch_FALSE;
+            // [                    patch cache                            |       *edCovers cache      ]
+            // [           (cacheSize-kBestACacheSize*?)                   |     (kBestACacheSize*?)    ]
+            *ptemp_cache=temp_cache;
+            *ptemp_cache_end=temp_cache_end;
+            return hpatch_FALSE;
+        }else{
+            // [         arrayCovers cache         |                         ...                        ]
+            // [((new temp_cache)-(old temp_cache))|          (cacheSize-(arrayCovers cache size))      ]
+            TByte* old_cache_end;
+            hpatch_TStreamInput* replace_oldData=0;
+            assert(!(*out_isReadError));
+            if (!((*out_covers)->close(*out_covers))) return _hpatch_FALSE;
+            *out_covers=&arrayCovers->ICovers;
+            temp_cache_end=temp_cache_end_back; //free compressedCovers or packedCovers memory
+            old_cache_end=temp_cache_end-kBestACacheSize*kCacheCount;
+            // [       arrayCovers cache           |        ...        |      patch reserve cache       ]
+            // [                                   |        ...        | (kBestACacheSize*kCacheCount) ]
+            if (((hpatch_size_t)(temp_cache_end-temp_cache)<=kBestACacheSize*kCacheCount)
+                ||(!_cache_old(&replace_oldData,oldData,arrayCovers,out_isReadError,
+                               temp_cache,&old_cache_end,temp_cache_end))){
+                if (*out_isReadError) return _hpatch_FALSE;
+            // [         arrayCovers cache         |                   patch cache                      ]
+                *ptemp_cache=temp_cache;
+                *ptemp_cache_end=temp_cache_end;
+                return hpatch_FALSE;
+            }else{
+            // [         arrayCovers cache         | oldData cache |             patch cache            ]
+            // [                                   |               |(temp_cache_end-(new old_cache_end))]
+                assert(!(*out_isReadError));
+                assert((hpatch_size_t)(temp_cache_end-old_cache_end)>=kBestACacheSize*kCacheCount);
+                temp_cache=old_cache_end;
+                
+                *poldData=replace_oldData;
+                *ptemp_cache=temp_cache;
+                *ptemp_cache_end=temp_cache_end;
+                return hpatch_TRUE;
+            }
+        }
+    }
+#endif//_IS_NEED_CACHE_OLD_BY_COVERS
+    return hpatch_FALSE;//not cache oldData
+}
+
+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;
+}
+
+hpatch_BOOL patch_stream(const hpatch_TStreamOutput* out_newData,
+                         const hpatch_TStreamInput*  oldData,
+                         const hpatch_TStreamInput*  serializedDiff){
+    TByte temp_cache[hpatch_kStreamCacheSize*_kCachePatCount];
+    return _patch_stream_with_cache(out_newData,oldData,serializedDiff,0,
+                                    temp_cache,temp_cache+sizeof(temp_cache)/sizeof(TByte));
+}
+
+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_TRUE;
+    hpatch_TCovers* covers=0; //need close before return
+    hpatch_BOOL    isReadError=hpatch_FALSE;
+#if (_HPATCH_IS_USED_MULTITHREAD)
+    hinput_mt_safe_t _safeDiff;
+    hpatch_TStreamInput* psafeDiff=0;
+    if (decompressPlugin && (decompressPlugin->dec_threadNum>1)){
+        psafeDiff=hinput_mt_safe_open(&_safeDiff,compressedDiff);
+        if (!psafeDiff){ result=_hpatch_FALSE; goto _clear; }
+        compressedDiff=psafeDiff;
+    }
+#endif
+    _patch_cache(&covers,&oldData,out_newData->streamSize,compressedDiff,hpatch_TRUE,
+                 decompressPlugin,_kCacheDecCount,&temp_cache,&temp_cache_end,&isReadError);
+    if (isReadError){ result=_hpatch_FALSE; goto _clear; }
+    result=_patch_decompress_cache(out_newData,oldData,compressedDiff,decompressPlugin,
+                                   covers,temp_cache,temp_cache_end);
+_clear:
+    if ((covers!=0)&&(!covers->close(covers))) result=_hpatch_FALSE;
+#if (_HPATCH_IS_USED_MULTITHREAD)
+    if (psafeDiff) hinput_mt_safe_close(psafeDiff);
+#endif
+    return result;
+}
+
+hpatch_BOOL patch_decompress(const hpatch_TStreamOutput* out_newData,
+                             const hpatch_TStreamInput*  oldData,
+                             const hpatch_TStreamInput*  compressedDiff,
+                             hpatch_TDecompress* decompressPlugin){
+    TByte temp_cache[hpatch_kStreamCacheSize*_kCacheDecCount];
+    return _patch_decompress_cache(out_newData,oldData,compressedDiff,decompressPlugin,
+                                   0,temp_cache,temp_cache+sizeof(temp_cache)/sizeof(TByte));
+}
+
+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;
+}
+
+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;
+}
+
+//
+
+hpatch_BOOL _patch_single_compressed_diff_mt(const hpatch_TStreamOutput* out_newData,
+                                             const hpatch_TStreamInput*  oldData,
+                                             const hpatch_TStreamInput*  singleCompressedDiff,
+                                             hpatch_StreamPos_t          diffData_pos,
+                                             hpatch_StreamPos_t          uncompressedSize,
+                                             hpatch_StreamPos_t          compressedSize,
+                                             hpatch_TDecompress*         decompressPlugin,
+                                             hpatch_StreamPos_t coverCount,hpatch_size_t stepMemSize,
+                                             unsigned char* temp_cache,unsigned char* temp_cache_end,
+                                             sspatch_coversListener_t* coversListener,
+                                             size_t maxThreadNum,hpatchMTSets_t hpatchMTSets){
+#if (_HPATCH_IS_USED_MULTITHREAD)
+    struct hpatch_mt_manager_t* hpatch_mt_manager=0;
+    hpatchMTSets_t mtsets=hpatch_getMTSets(out_newData->streamSize,oldData->streamSize,singleCompressedDiff->streamSize-diffData_pos,
+                                           compressedSize?decompressPlugin:0,_kCacheSgCount,stepMemSize,
+                                           temp_cache_end-temp_cache,maxThreadNum,hpatchMTSets);
+#endif
+    hpatch_BOOL result;
+    hpatch_BOOL isNeedOutCache=hpatch_TRUE;
+    size_t      kCacheCount=_kCacheSgCount;
+    hpatch_TUncompresser_t uncompressedStream={0};
+    hpatch_StreamPos_t diffData_posEnd;
+    if (compressedSize==0){
+        decompressPlugin=0;
+    }else{
+        if (decompressPlugin==0) return _hpatch_FALSE;
+    }
+    diffData_posEnd=(decompressPlugin?compressedSize:uncompressedSize)+diffData_pos;
+    if (diffData_posEnd>singleCompressedDiff->streamSize) return _hpatch_FALSE;
+#if (_HPATCH_IS_USED_MULTITHREAD)
+    if (_hpatchMTSets_threadNum(mtsets)>1){
+        isNeedOutCache=!mtsets.writeNew_isMT;
+        kCacheCount=_kCacheSgCount-(isNeedOutCache?0:1);
+        hpatch_mt_manager=hpatch_mt_manager_open(&out_newData,&oldData,&singleCompressedDiff,
+                                                 &diffData_pos,&diffData_posEnd,uncompressedSize,&decompressPlugin,
+                                                 stepMemSize,&temp_cache,&temp_cache_end,&coversListener,hpatch_TRUE,
+                                                 kCacheCount,mtsets);
+        if (!hpatch_mt_manager) return _hpatch_FALSE;
+    }
+#endif
+    if (decompressPlugin){
+        if (!compressed_stream_as_uncompressed(&uncompressedStream,uncompressedSize,decompressPlugin,singleCompressedDiff,
+                                               diffData_pos,diffData_posEnd)) return _hpatch_FALSE;
+        singleCompressedDiff=&uncompressedStream.base;
+        diffData_pos=0;
+        diffData_posEnd=singleCompressedDiff->streamSize;
+    }
+
+    result=patch_single_stream_diff(out_newData,oldData,singleCompressedDiff,diffData_pos,diffData_posEnd,
+                                    coverCount,stepMemSize,temp_cache,temp_cache_end,coversListener,isNeedOutCache);
+
+    if (decompressPlugin)
+        close_compressed_stream_as_uncompressed(&uncompressedStream);
+#if (_HPATCH_IS_USED_MULTITHREAD)
+    if (hpatch_mt_manager){
+        if (!hpatch_mt_manager_close(hpatch_mt_manager,!result))
+            result=_hpatch_FALSE;
+        hpatch_mt_manager=0;
+    }
+#endif
+    return result;
+}
+
+static const size_t _kStepMemSizeSafeLimit =(1<<20)*4;
+hpatch_BOOL getSingleCompressedDiffInfo(hpatch_singleCompressedDiffInfo* out_diffInfo,
+                                        const hpatch_TStreamInput* singleCompressedDiff,
+                                        hpatch_StreamPos_t         diffInfo_pos){
+    TStreamCacheClip  _diffHeadClip;
+    TStreamCacheClip* diffHeadClip=&_diffHeadClip;
+    TByte             temp_cache[hpatch_kStreamCacheSize];
+    _TStreamCacheClip_init(&_diffHeadClip,singleCompressedDiff,diffInfo_pos,singleCompressedDiff->streamSize,
+                           temp_cache,hpatch_kStreamCacheSize);
+    {//type
+        const char* kVersionType="HDIFFSF20";
+        char* tempType=out_diffInfo->compressType;
+        if (!_TStreamCacheClip_readType_end(diffHeadClip,'&',tempType)) return _hpatch_FALSE;
+        if (0!=strcmp(tempType,kVersionType)) return _hpatch_FALSE;
+    }
+    {//read compressType
+        if (!_TStreamCacheClip_readType_end(diffHeadClip,'\0',
+                                            out_diffInfo->compressType)) return _hpatch_FALSE;
+    }
+    _clip_unpackUIntTo(&out_diffInfo->newDataSize,diffHeadClip);
+    _clip_unpackUIntTo(&out_diffInfo->oldDataSize,diffHeadClip);
+    _clip_unpackUIntTo(&out_diffInfo->coverCount,diffHeadClip);
+    _clip_unpackUIntTo(&out_diffInfo->stepMemSize,diffHeadClip);
+    _clip_unpackUIntTo(&out_diffInfo->uncompressedSize,diffHeadClip);
+    _clip_unpackUIntTo(&out_diffInfo->compressedSize,diffHeadClip);
+    out_diffInfo->diffDataPos=_TStreamCacheClip_readPosOfSrcStream(diffHeadClip)-diffInfo_pos;
+    if (out_diffInfo->compressedSize>out_diffInfo->uncompressedSize)
+        return _hpatch_FALSE;
+    if (out_diffInfo->stepMemSize>(out_diffInfo->newDataSize+_kStepMemSizeSafeLimit))
+        return _hpatch_FALSE;
+    if (out_diffInfo->stepMemSize>out_diffInfo->uncompressedSize+_kStepMemSizeSafeLimit)
+        return _hpatch_FALSE;
+    return hpatch_TRUE;
+}
+
+static hpatch_BOOL _TUncompresser_read(const struct hpatch_TStreamInput* stream,hpatch_StreamPos_t readFromPos,
+                                       unsigned char* out_data,unsigned char* out_data_end){
+    hpatch_TUncompresser_t* self=(hpatch_TUncompresser_t*)stream->streamImport;
+    return self->_decompressPlugin->decompress_part(self->_decompressHandle,out_data,out_data_end);
+}
+
+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;
+}
+
+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;
+}
+
+typedef struct{
+    const unsigned char* code;
+    const unsigned char* code_end;
+    hpatch_size_t   len0;
+    hpatch_size_t   lenv;
+    hpatch_BOOL     isNeedDecode0;
+} rle0_decoder_t;
+
+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;
+}
+
+static hpatch_BOOL _rle0_decoder_add(rle0_decoder_t* self,TByte* out_data,hpatch_size_t decodeSize){
+    if (self->len0){
+    _0_process:
+        if (self->len0>=decodeSize){
+            self->len0-=decodeSize;
+            return hpatch_TRUE;
+        }else{
+            decodeSize-=self->len0;
+            out_data+=self->len0;
+            self->len0=0;
+            goto _decode_v_process;
+        }
+    }
+    
+    if (self->lenv){
+    _v_process:
+        if (self->lenv>=decodeSize){
+            addData(out_data,self->code,decodeSize);
+            self->code+=decodeSize;
+            self->lenv-=decodeSize;
+            return hpatch_TRUE;
+        }else{
+            addData(out_data,self->code,self->lenv);
+            out_data+=self->lenv;
+            decodeSize-=self->lenv;
+            self->code+=self->lenv;
+            self->lenv=0;
+            goto _decode_0_process;
+        }
+    }
+    
+    assert(decodeSize>0);
+    if (self->isNeedDecode0){
+        hpatch_StreamPos_t len0;
+    _decode_0_process:
+        self->isNeedDecode0=hpatch_FALSE;
+        if (!hpatch_unpackUInt(&self->code,self->code_end,&len0)) return _hpatch_FALSE;
+        if (len0!=(hpatch_size_t)len0) return _hpatch_FALSE;
+        self->len0=(hpatch_size_t)len0;
+        goto _0_process;
+    }else{
+        hpatch_StreamPos_t lenv;
+    _decode_v_process:
+        self->isNeedDecode0=hpatch_TRUE;
+        if (!hpatch_unpackUInt(&self->code,self->code_end,&lenv)) return _hpatch_FALSE;
+        if (lenv>(size_t)(self->code_end-self->code)) return _hpatch_FALSE;
+        self->lenv=(hpatch_size_t)lenv;
+        goto _v_process;
+    }
+}
+
+
+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;
+}
+
+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;
+}
+
+
+#if (_IS_NEED_CACHE_OLD_BY_COVERS)
+
+#define     _kMaxCachedLen_min      (32*1024)   // 1M is big value, 256k is middle value, 32k is small value
+#define     _kMaxCachedLen_max      (32*_kMaxCachedLen_min)
+#define     _kMemForReadOldSize     (hpatch_kFileIOBufBetterSize*2)
+
+typedef struct{
+    _cache_old_TStreamInput     cache_old;
+    hpatch_TStreamInput         base;
+    sspatch_covers_t            covers;
+    hpatch_BOOL                 isHaveACover;
+    hpatch_size_t               sumCacheLen;
+    hpatch_byte*                cache_buf_end;
+    const hpatch_byte*          covers_cache;
+    const hpatch_byte*          covers_cacheEnd;
+} _step_cache_old_t;
+
+static hpatch_force_inline hpatch_size_t _step_cache_old_sumBufSize(const _step_cache_old_t* self){
+                                                return self->cache_old.cachesEnd-(const hpatch_byte*)self->cache_old.arrayCovers.pCCovers; }
+static hpatch_force_inline hpatch_size_t _step_cache_old_coverBufSize(const _step_cache_old_t* self){
+                                                return (hpatch_size_t)arrayCovers_memSize(self->cache_old.arrayCovers.coverCount,self->cache_old.arrayCovers.is32); }
+static hpatch_force_inline hpatch_StreamPos_t _step_cache_old_incCoverBufSize(const _step_cache_old_t* self){
+                                                return arrayCovers_memSize(self->cache_old.arrayCovers.coverCount+1,self->cache_old.arrayCovers.is32); }
+
+
+static hpatch_BOOL _step_cache_old_addCover(_step_cache_old_t* self,const hpatch_TCover* cover){
+    const hpatch_StreamPos_t _incCoverBufSize=_step_cache_old_incCoverBufSize(self);
+    while (hpatch_TRUE){
+        const hpatch_size_t _addCachedLen=(cover->length<=self->cache_old.maxCachedLen)?(hpatch_size_t)cover->length:0;
+        if (_incCoverBufSize+self->sumCacheLen+_addCachedLen<=_step_cache_old_sumBufSize(self)){
+            self->sumCacheLen+=_addCachedLen;
+            _arrayCovers_push_cover(&self->cache_old.arrayCovers,cover);
+            return hpatch_TRUE;
+        }else{
+            assert(self->cache_old.maxCachedLen>=_kMaxCachedLen_min);
+            if (self->cache_old.maxCachedLen==_kMaxCachedLen_min) return hpatch_FALSE;
+            self->cache_old.maxCachedLen/=2;
+            self->sumCacheLen=(hpatch_size_t)_getCacheSumLen(&self->cache_old.arrayCovers,self->cache_old.maxCachedLen);
+        }
+    }
+}
+
+static hpatch_BOOL _patch_step_cache_old_update(void* _self){
+    _step_cache_old_t* self=(_step_cache_old_t*)_self;
+    hpatch_StreamPos_t oldPosBegin;
+    hpatch_StreamPos_t oldPosEnd;
+    const hpatch_size_t kMinCacheCoverCount=0; //no limit
+    assert(self->cache_old.arrayCovers.coverCount<=self->cache_old.arrayCovers.cur_index);
+    assert(self->cache_old.caches==self->cache_old.cachesEnd);
+    self->sumCacheLen=0;
+    self->cache_old.arrayCovers.coverCount=0;
+    self->cache_old.arrayCovers.cur_index=0;
+    self->cache_old.cachesEnd=self->cache_buf_end-_kMemForReadOldSize; //limit covers + cached data 's size
+    self->cache_old.maxCachedLen=_kMaxCachedLen_max;
+    while ((self->cache_old.maxCachedLen>=_step_cache_old_sumBufSize(self))&&(self->cache_old.maxCachedLen>_kMaxCachedLen_min))
+        self->cache_old.maxCachedLen/=2;
+
+    //read some cover from self->covers to self->cache_old.arrayCovers
+    if (self->isHaveACover){
+        self->isHaveACover=hpatch_FALSE;
+        assert(self->covers.cover.length>0);
+        if (!_step_cache_old_addCover(self,&self->covers.cover)) assert(hpatch_FALSE);
+    }
+    while (sspatch_covers_isHaveNextCover(&self->covers)){
+        if (!sspatch_covers_nextCover(&self->covers))
+            return hpatch_FALSE;
+        if (self->covers.cover.length>0){
+            if (_step_cache_old_addCover(self,&self->covers.cover)){
+                //ok
+            }else{
+                self->isHaveACover=hpatch_TRUE;
+                break; //arrayCovers full
+            }
+        }
+    }
+
+    self->cache_old.maxCachedLen=_getMaxCachedLen(&self->cache_old.arrayCovers,_step_cache_old_sumBufSize(self)-_step_cache_old_coverBufSize(self));
+    assert(self->cache_old.maxCachedLen>0);
+    self->sumCacheLen=_set_cache_pos(&self->cache_old.arrayCovers,self->cache_old.maxCachedLen,&oldPosBegin,&oldPosEnd,kMinCacheCoverCount);
+    self->cache_old.caches=((hpatch_byte*)self->cache_old.arrayCovers.pCCovers)+_step_cache_old_coverBufSize(self);
+    self->cache_old.cachesEnd=self->cache_old.caches+self->sumCacheLen;
+    if (self->sumCacheLen>0){
+        if (!_cache_old_load(self->cache_old.oldData,oldPosBegin,oldPosEnd,&self->cache_old.arrayCovers,
+                             self->cache_old.maxCachedLen,self->sumCacheLen, (hpatch_byte*)self->cache_old.caches,
+                             (hpatch_byte*)self->cache_old.cachesEnd,self->cache_buf_end))
+            return _hpatch_FALSE;
+    }
+    return hpatch_TRUE;
+}
+
+static hpatch_inline
+void _patch_step_cache_old_init(_step_cache_old_t* self,hpatch_size_t canUsedMemSize,
+                                const hpatch_TStreamInput* oldData,hpatch_BOOL isUsedCover32){
+    memset(self,0,sizeof(*self));
+    assert(canUsedMemSize>=_kMemForReadOldSize*2);
+    self->base.streamImport=&self->cache_old;
+    self->base.streamSize=oldData->streamSize;
+    self->base.read=_cache_old_StreamInput_read;
+    //todo: _cache_old_StreamInput_read call back
+    self->cache_old.oldData=oldData;
+    self->cache_old._cacheImport=self;
+    self->cache_old._doUpdateCacheCovers=_patch_step_cache_old_update;
+    self->cache_buf_end=((hpatch_byte*)self) + canUsedMemSize;
+
+    self->cache_old.arrayCovers.is32=isUsedCover32;
+    self->cache_old.arrayCovers.pCCovers=(void*)_hpatch_align_upper((self+1),sizeof(hpatch_StreamPos_t));
+    self->cache_old.arrayCovers.ICovers.leave_cover_count=_arrayCovers_leaveCoverCount;
+    self->cache_old.arrayCovers.ICovers.read_cover=_arrayCovers_read_cover;
+}
+
+
+hpatch_BOOL _patch_step_cache_old_onStepCovers(const hpatch_TStreamInput* _self,const unsigned char* covers_cache,const unsigned char* covers_cacheEnd){
+    _step_cache_old_t* self=(_step_cache_old_t*)_self->streamImport;
+    assert(!sspatch_covers_isHaveNextCover(&self->covers));
+    assert(!self->isHaveACover);
+    self->covers_cache=covers_cache;
+    self->covers_cacheEnd=covers_cacheEnd;
+    sspatch_covers_setCoversCache(&self->covers,covers_cache,covers_cacheEnd);
+    return covers_cache?_patch_step_cache_old_update(self):hpatch_TRUE;
+}
+
+
+hpatch_size_t _patch_step_cache_old_canUsedSize(hpatch_size_t stepCoversMemSize,hpatch_size_t kMinTempCacheSize,hpatch_size_t tempCacheSize){
+    const hpatch_size_t  kActiveCacheOldMemorySize=(1<<20)*3+_kMemForReadOldSize*2;
+    hpatch_size_t cacheStepSize,multiple;
+    if (tempCacheSize<kActiveCacheOldMemorySize+stepCoversMemSize+kMinTempCacheSize)
+        return 0;
+    cacheStepSize=tempCacheSize-(stepCoversMemSize+kMinTempCacheSize+sizeof(hpatch_StreamPos_t));
+    multiple=cacheStepSize/((kActiveCacheOldMemorySize+kMinTempCacheSize+_kMemForReadOldSize)/4);
+    cacheStepSize-=(hpatch_size_t)((hpatch_StreamPos_t)(kMinTempCacheSize+_kMemForReadOldSize)*((multiple>4)?(hpatch_size_t)(multiple-4):0)/8);
+    return cacheStepSize;
+}
+
+hpatch_BOOL _patch_step_cache_old(const hpatch_TStreamInput** poldData,hpatch_StreamPos_t newDataSize,size_t stepCoversMemSize,
+                                  size_t kMinTempCacheSize,hpatch_byte** ptemp_cache,hpatch_byte** ptemp_cache_end){
+    const hpatch_TStreamInput* oldData=*poldData;
+    _step_cache_old_t*  self;
+    const hpatch_BOOL   isUsedCover32=(oldData->streamSize|newDataSize)<((hpatch_uint64_t)1<<32);
+    hpatch_byte* temp_cache=*ptemp_cache;
+    hpatch_byte* const temp_cache_end=*ptemp_cache_end;
+
+    hpatch_size_t canUsedMemSize=_patch_step_cache_old_canUsedSize(stepCoversMemSize,kMinTempCacheSize,temp_cache_end-temp_cache);
+    if (canUsedMemSize==0)
+        return hpatch_FALSE; //not enough memory for cache part of oldData
+    _cache_alloc(self,_step_cache_old_t,canUsedMemSize,temp_cache,temp_cache_end);
+    _patch_step_cache_old_init(self,canUsedMemSize,oldData,isUsedCover32);
+
+    *poldData=&self->base;
+    *ptemp_cache=temp_cache;
+    return hpatch_TRUE;
+}
+
+#endif // _IS_NEED_CACHE_OLD_BY_COVERS
+
+
+hpatch_size_t _patch_is_can_cache_window_old_canUsedSize(hpatch_size_t windowOldBufSize,hpatch_size_t stepCoversMemSize,
+                                                         hpatch_size_t kMinTempCacheSize,hpatch_size_t tempCacheSize,hpatch_StreamPos_t oldDataSize){
+    hpatch_size_t result=(windowOldBufSize*2<oldDataSize)?windowOldBufSize*2:(hpatch_size_t)oldDataSize;
+    const hpatch_size_t mt_needSize=result+stepCoversMemSize+kMinTempCacheSize;
+    hpatch_size_t cacheStepSize;
+    if ((windowOldBufSize==0)||(tempCacheSize<mt_needSize))
+        return 0;
+    cacheStepSize=tempCacheSize-mt_needSize;
+    if (cacheStepSize<=kMinTempCacheSize)
+        return result;
+    result+=(cacheStepSize-kMinTempCacheSize)*1/2;
+    return (result<oldDataSize)?result:(hpatch_size_t)oldDataSize;
+}
+
+static hpatch_BOOL _patch_single_stream_loop(TStreamCacheClip* inClip,_TOutStreamCache* outCache,
+                                             const hpatch_TStreamInput* oldData,hpatch_StreamPos_t coverCount,
+                                             hpatch_size_t stepMemSize,unsigned char* step_cache,
+                                             unsigned char* temp_cache,hpatch_size_t cache_size,
+                                             sspatch_coversListener_t* coversListener
+#if (_IS_NEED_CACHE_OLD_BY_COVERS)
+                                             ,hpatch_BOOL isCachedOldByStep
+#endif
+                                             ){
+    sspatch_covers_t covers;
+    sspatch_covers_init(&covers);
+    if (coversListener) assert(coversListener->onStepCovers);
+
+    while (coverCount){
+        rle0_decoder_t rle0_decoder;
+        {//read step info
+            unsigned char* covers_cacheEnd;
+            unsigned char* bufRle_cache_end;
+            {
+                hpatch_StreamPos_t bufCover_size;
+                hpatch_StreamPos_t bufRle_size;
+                _clip_unpackUIntTo(&bufCover_size,inClip);
+                _clip_unpackUIntTo(&bufRle_size,inClip);
+                #ifdef __RUN_MEM_SAFE_CHECK
+                    if ((bufCover_size>stepMemSize)||(bufRle_size>stepMemSize)||
+                        (bufCover_size+bufRle_size>stepMemSize)) return _hpatch_FALSE;
+                #endif
+                covers_cacheEnd=step_cache+(size_t)bufCover_size;
+                bufRle_cache_end=covers_cacheEnd+(size_t)bufRle_size;
+            }
+            if (coversListener&&coversListener->onStepCoversReset)
+                coversListener->onStepCoversReset(coversListener,coverCount);
+            if (!_TStreamCacheClip_readDataTo(inClip,step_cache,bufRle_cache_end))
+                return _hpatch_FALSE;
+            if (coversListener)
+                coversListener->onStepCovers(coversListener,step_cache,covers_cacheEnd);
+        #if (_IS_NEED_CACHE_OLD_BY_COVERS)
+            if (isCachedOldByStep)
+                _patch_step_cache_old_onStepCovers(oldData,step_cache,covers_cacheEnd);
+        #endif
+            sspatch_covers_setCoversCache(&covers,step_cache,covers_cacheEnd);
+            _rle0_decoder_init(&rle0_decoder,covers_cacheEnd,bufRle_cache_end);
+        }
+        while (sspatch_covers_isHaveNextCover(&covers)){
+            if (!sspatch_covers_nextCover(&covers))
+                return _hpatch_FALSE;
+            if (covers.cover.newPos>covers.lastNewEnd){
+                if (!_TOutStreamCache_copyFromClip(outCache,inClip,covers.cover.newPos-covers.lastNewEnd))
+                    return _hpatch_FALSE;
+            }
+
+            --coverCount;
+            if (covers.cover.length){
+                #ifdef __RUN_MEM_SAFE_CHECK
+                    if ((covers.cover.oldPos>oldData->streamSize)||
+                        (covers.cover.length>(hpatch_StreamPos_t)(oldData->streamSize-covers.cover.oldPos))) return _hpatch_FALSE;
+                #endif
+                if (!_patch_add_old_with_rle0(outCache,&rle0_decoder,oldData,covers.cover.oldPos,covers.cover.length,
+                                              temp_cache,cache_size)) return _hpatch_FALSE;
+            }else{
+                #ifdef __RUN_MEM_SAFE_CHECK
+                    if (coverCount!=0) return _hpatch_FALSE;
+                #endif
+            }
+        }
+    }
+    if (coversListener){
+        if (coversListener->onStepCoversReset)
+            coversListener->onStepCoversReset(coversListener,0);
+        coversListener->onStepCovers(coversListener,0,0);
+    }
+
+    return hpatch_TRUE;
+}
+
+
+hpatch_BOOL patch_single_stream_diff(const hpatch_TStreamOutput*  out_newData,
+                                     const hpatch_TStreamInput*   oldData,
+                                     const hpatch_TStreamInput*   uncompressedDiffData,
+                                     hpatch_StreamPos_t           diffData_pos,
+                                     hpatch_StreamPos_t           diffData_posEnd,
+                                     hpatch_StreamPos_t coverCount,hpatch_size_t stepMemSize,
+                                     unsigned char* temp_cache,unsigned char* temp_cache_end,
+                                     sspatch_coversListener_t* coversListener,hpatch_BOOL isNeedOutCache){
+    unsigned char*      step_cache;
+    hpatch_size_t       cache_size;
+    TStreamCacheClip    inClip;
+    _TOutStreamCache    outCache;
+    const size_t        kCacheCount=_kCacheSgCount-(isNeedOutCache?0:1);
+#if (_IS_NEED_CACHE_OLD_BY_COVERS)
+    hpatch_BOOL         isCachedOldByStep=hpatch_FALSE;
+#endif
+
+    step_cache=temp_cache;
+    assert(diffData_posEnd<=uncompressedDiffData->streamSize);
+    if (coversListener) assert(coversListener->onStepCovers);
+    {//cache
+        hpatch_BOOL isCachedAllOld;
+        hpatch_BOOL isReadError=hpatch_FALSE;
+        if ((size_t)(temp_cache_end-temp_cache)<stepMemSize+hpatch_kStreamCacheSize*kCacheCount) return _hpatch_FALSE;
+        temp_cache+=stepMemSize;
+        isCachedAllOld=_patch_cache_all_old(&oldData,kCacheCount*hpatch_kStreamCacheSize,&temp_cache,&temp_cache_end,&isReadError);
+        if (isReadError) return _hpatch_FALSE;
+    #if (_IS_NEED_CACHE_OLD_BY_COVERS)
+        if (!isCachedAllOld)
+            isCachedOldByStep=_patch_step_cache_old(&oldData,out_newData->streamSize,stepMemSize,
+                                                    kCacheCount*hpatch_kFileIOBufBetterSize,&temp_cache,&temp_cache_end);
+    #endif
+        cache_size=(temp_cache_end-temp_cache)/kCacheCount;
+        _TStreamCacheClip_init(&inClip,uncompressedDiffData,diffData_pos,diffData_posEnd,
+                               temp_cache,cache_size);
+        temp_cache+=cache_size;
+        _TOutStreamCache_init(&outCache,out_newData,isNeedOutCache?temp_cache:0,isNeedOutCache?cache_size:0);
+        if (isNeedOutCache) temp_cache+=cache_size;
+    }
+
+    if (!_patch_single_stream_loop(&inClip,&outCache,oldData,coverCount,stepMemSize,
+                                   step_cache,temp_cache,cache_size,coversListener
+    #if (_IS_NEED_CACHE_OLD_BY_COVERS)
+                              ,isCachedOldByStep
+    #endif
+                              ))
+        return _hpatch_FALSE;
+
+    if (!_TOutStreamCache_flush(&outCache))
+        return _hpatch_FALSE;
+    if (_TStreamCacheClip_isFinish(&inClip)&&_TOutStreamCache_isFinish(&outCache))
+        return hpatch_TRUE;
+    else
+        return _hpatch_FALSE;
+}
+
+
+static hpatch_BOOL _TDiffToSingleStream_read(const struct hpatch_TStreamInput* stream,hpatch_StreamPos_t readFromPos,
+                                           unsigned char* out_data,unsigned char* out_data_end){
+    //[                                                         |readedSize                  ]
+    //     [     |cachedBufBegin   _TDiffToSingleStream_kBufSize]
+    //                                 readFromPos[out_data       out_data_end]
+    TDiffToSingleStream* self=(TDiffToSingleStream*)stream->streamImport;
+    hpatch_StreamPos_t readedSize=self->readedSize;
+    while (1){
+        size_t rLen=out_data_end-out_data;
+        if (readFromPos==readedSize){
+            hpatch_BOOL result=self->diffStream->read(self->diffStream,readedSize,out_data,out_data_end);
+            self->readedSize=readedSize+rLen;
+            if ((self->isInSingleStream)||(rLen>_TDiffToSingleStream_kBufSize)){
+                self->cachedBufBegin=_TDiffToSingleStream_kBufSize;
+            }else{
+                //cache
+                if (rLen>=_TDiffToSingleStream_kBufSize){
+                    memcpy(self->buf,out_data_end-_TDiffToSingleStream_kBufSize,_TDiffToSingleStream_kBufSize);
+                    self->cachedBufBegin = 0;
+                }else{
+                    size_t new_cachedBufBegin;
+                    if (self->cachedBufBegin>=rLen){
+                        new_cachedBufBegin=self->cachedBufBegin-rLen;
+                        memmove(self->buf+new_cachedBufBegin,self->buf+self->cachedBufBegin,_TDiffToSingleStream_kBufSize-self->cachedBufBegin);
+                    }else{
+                        new_cachedBufBegin=0;
+                        memmove(self->buf,self->buf+rLen,_TDiffToSingleStream_kBufSize-rLen);
+                    }
+                    memcpy(self->buf+(_TDiffToSingleStream_kBufSize-rLen),out_data,rLen);
+                    self->cachedBufBegin=new_cachedBufBegin;
+                }
+            }
+            return result;
+        }else{
+            size_t cachedSize=_TDiffToSingleStream_kBufSize-self->cachedBufBegin;
+            size_t bufSize=(size_t)(readedSize-readFromPos);
+            if ((readFromPos<readedSize)&&(bufSize<=cachedSize)){
+                if (rLen>bufSize)
+                    rLen=bufSize;
+                memcpy(out_data,self->buf+(_TDiffToSingleStream_kBufSize-bufSize),rLen);
+                out_data+=rLen;
+                readFromPos+=rLen;
+                if (out_data==out_data_end) 
+                    return hpatch_TRUE;
+                else
+                    continue;
+            }else{
+                return _hpatch_FALSE;
+            }
+        }
+    }
+}
+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;
+}
+
+hpatch_BOOL _patch_single_stream_mt(sspatch_listener_t* listener,
+                                    const hpatch_TStreamOutput* __out_newData,
+                                    const hpatch_TStreamInput*  oldData,
+                                    const hpatch_TStreamInput*  singleCompressedDiff, 
+                                    hpatch_StreamPos_t  diffInfo_pos,
+                                    sspatch_coversListener_t* coversListener,
+                                    size_t maxThreadNum,hpatchMTSets_t hpatchMTSets){
+    hpatch_BOOL result=hpatch_TRUE;
+    hpatch_TDecompress*     decompressPlugin=0;
+    unsigned char*          temp_cache=0;
+    unsigned char*          temp_cacheEnd=0;
+    hpatch_singleCompressedDiffInfo diffInfo;
+    hpatch_TStreamOutput    _out_newData=*__out_newData;
+    hpatch_TStreamOutput*   out_newData=&_out_newData;
+    TDiffToSingleStream     _toSStream;
+    assert((listener)&&(listener->onDiffInfo));
+    TDiffToSingleStream_init(&_toSStream,singleCompressedDiff);
+    singleCompressedDiff=&_toSStream.base;
+
+    if (!getSingleCompressedDiffInfo(&diffInfo,singleCompressedDiff,diffInfo_pos))
+        return _hpatch_FALSE;
+    if (diffInfo.newDataSize>out_newData->streamSize)
+        return _hpatch_FALSE;
+    out_newData->streamSize=diffInfo.newDataSize;
+    if (diffInfo.oldDataSize!=oldData->streamSize)
+        return _hpatch_FALSE;
+    if (!listener->onDiffInfo(listener,&diffInfo,&decompressPlugin,&temp_cache,&temp_cacheEnd))
+        return _hpatch_FALSE;
+
+    if ((temp_cache==0)||(temp_cache>=temp_cacheEnd))
+        result=_hpatch_FALSE;
+    if (result){
+        result=_patch_single_compressed_diff_mt(out_newData,oldData,singleCompressedDiff,diffInfo.diffDataPos,
+                                                diffInfo.uncompressedSize,diffInfo.compressedSize,decompressPlugin,
+                                                diffInfo.coverCount,(size_t)diffInfo.stepMemSize,
+                                                temp_cache,temp_cacheEnd,coversListener,maxThreadNum,hpatchMTSets);
+    }
+    if (listener->onPatchFinish)
+        listener->onPatchFinish(listener,temp_cache,temp_cacheEnd);
+    return result;
+}
+
+
+static hpatch_BOOL _getWindowDiffInfo(hpatch_windowDiffInfo* out_diffInfo,
+                                      const hpatch_TStreamInput* windowDiff,hpatch_StreamPos_t diffInfo_pos,
+                                       unsigned char* headBuf,    // [hpatch_kWindowDiffHeadMaxSize]
+                                       hpatch_size_t* headSize){  // in headBuf size, out headData size 
+    const char* kVersionType="HDIFFW26";
+    const size_t kVersionLen=strlen(kVersionType);
+    const size_t kHeadPrefixSize=kVersionLen+2;
+    hpatch_size_t headRemainingSize;
+    hpatch_TStreamInput headMemStream;
+    TStreamCacheClip   _headClip;
+    TStreamCacheClip*  diffHeadClip=&_headClip;
+    TByte              _temp_cache[hpatch_kMaxPluginTypeLength];
+    assert(out_diffInfo!=0);
+    assert(windowDiff!=0);
+    assert(windowDiff->read!=0);
+    assert(headBuf!=0);
+    assert(headSize!=0);
+
+    //read "HDIFFW26" + headRemainingSize
+    if (kHeadPrefixSize>(*headSize)) return _hpatch_FALSE;
+    if (!windowDiff->read(windowDiff,diffInfo_pos,headBuf,headBuf+kHeadPrefixSize))
+        return _hpatch_FALSE;
+    if (0!=memcmp(headBuf,"HDIFFW26",kVersionLen))
+        return _hpatch_FALSE;
+    headRemainingSize=(hpatch_size_t)headBuf[kVersionLen] | ((hpatch_size_t)headBuf[kVersionLen+1]<<8);
+    if (headRemainingSize+kHeadPrefixSize>(*headSize))
+        return _hpatch_FALSE;
+
+    //read remaining head data
+    if (!windowDiff->read(windowDiff,diffInfo_pos+kHeadPrefixSize,
+                          headBuf+kHeadPrefixSize,headBuf+kHeadPrefixSize+headRemainingSize))
+        return _hpatch_FALSE;
+    *headSize=kHeadPrefixSize+headRemainingSize;
+    out_diffInfo->windowDataPos=kHeadPrefixSize+headRemainingSize;
+
+    //parse from headBuf (skip version+size, parse type string + packUInts)
+    mem_as_hStreamInput(&headMemStream,headBuf+kHeadPrefixSize,headBuf+kHeadPrefixSize+headRemainingSize);
+    _TStreamCacheClip_init(diffHeadClip,&headMemStream,0,headRemainingSize,_temp_cache,sizeof(_temp_cache));
+    if (!_TStreamCacheClip_readType_end(diffHeadClip,'&',out_diffInfo->compressType))
+        return _hpatch_FALSE;
+    if (!_TStreamCacheClip_readType_end(diffHeadClip,'\0',out_diffInfo->checksumType))
+        return _hpatch_FALSE;
+
+    //read header fields
+    _clip_unpackUIntTo(&out_diffInfo->compressedSize,diffHeadClip);
+    out_diffInfo->_headFixedInfoPos=kHeadPrefixSize+_TStreamCacheClip_readPosOfSrcStream(diffHeadClip);
+    _clip_unpackUIntTo(&out_diffInfo->uncompressedSize,diffHeadClip);
+    _clip_unpackUIntTo(&out_diffInfo->newDataSize,diffHeadClip);
+    _clip_unpackUIntTo(&out_diffInfo->oldDataSize,diffHeadClip);
+    _clip_unpackUIntTo(&out_diffInfo->coverCount,diffHeadClip);
+    _clip_unpackUIntTo(&out_diffInfo->windowCount,diffHeadClip);
+    _clip_unpackUIntTo(&out_diffInfo->windowMetaCount,diffHeadClip);
+    _clip_unpackUIntTo(&out_diffInfo->maxStepMemSize,diffHeadClip);
+    _clip_unpackUIntTo(&out_diffInfo->maxSubCoverCount,diffHeadClip);
+    _clip_unpackUIntTo(&out_diffInfo->maxWindowOldSize,diffHeadClip);
+    _clip_unpackUIntTo(&out_diffInfo->checksumByteSize,diffHeadClip);
+    _clip_unpackUIntTo(&out_diffInfo->extraDataSize,diffHeadClip);
+    
+    out_diffInfo->otherInfoPos=kHeadPrefixSize+_TStreamCacheClip_readPosOfSrcStream(diffHeadClip);
+    if (out_diffInfo->otherInfoPos+out_diffInfo->checksumByteSize*3>out_diffInfo->windowDataPos)
+        return _hpatch_FALSE;
+    out_diffInfo->otherInfoEndPos=out_diffInfo->windowDataPos-out_diffInfo->checksumByteSize*3;
+
+    if ((out_diffInfo->windowMetaCount>hpatch_kMaxWindowMetaCount)||(out_diffInfo->windowMetaCount<2))
+        return _hpatch_FALSE;
+    if ((out_diffInfo->windowMetaCount&(out_diffInfo->windowMetaCount-1))!=0) //2^N
+        return _hpatch_FALSE;
+    if (((out_diffInfo->checksumType[0]==0)&&(out_diffInfo->checksumByteSize!=0))
+      ||((out_diffInfo->checksumType[0]!=0)&&(out_diffInfo->checksumByteSize==0)))
+        return _hpatch_FALSE;
+    if (out_diffInfo->maxWindowOldSize>out_diffInfo->oldDataSize)
+        return _hpatch_FALSE;
+    if ((out_diffInfo->maxWindowOldSize>0)&&(out_diffInfo->windowCount==0))
+        return _hpatch_FALSE;
+    if (out_diffInfo->compressedSize>out_diffInfo->uncompressedSize)
+        return _hpatch_FALSE;
+    if (out_diffInfo->maxStepMemSize>(out_diffInfo->newDataSize+_kStepMemSizeSafeLimit))
+        return _hpatch_FALSE;
+    if (out_diffInfo->maxStepMemSize>out_diffInfo->uncompressedSize+_kStepMemSizeSafeLimit)
+        return _hpatch_FALSE;
+    return hpatch_TRUE;
+}
+
+hpatch_BOOL getWindowDiffInfo(hpatch_windowDiffInfo* out_diffInfo,const hpatch_TStreamInput* windowDiff,
+                              hpatch_StreamPos_t diffInfo_pos){
+    TByte         headBuf[hpatch_kWindowDiffHeadMaxSize];
+    hpatch_size_t headSize=sizeof(headBuf);
+    return _getWindowDiffInfo(out_diffInfo,windowDiff,diffInfo_pos,headBuf,&headSize);
+}
+
+static const size_t _kWindowCacheCount=_kCacheSgCount;
+
+    static hpatch_BOOL _cache_load_window_old(const hpatch_TStreamInput* oldData,unsigned char* oldBuf,
+                                              hpatch_StreamPos_t windowOldPos,hpatch_StreamPos_t windowOldLength,
+                                              hpatch_StreamPos_t* pLastOldPos,hpatch_StreamPos_t* pLastOldEnd){
+        const hpatch_StreamPos_t lastOldPos=*pLastOldPos;
+        const hpatch_StreamPos_t lastOldEnd=*pLastOldEnd;
+        const hpatch_StreamPos_t windowOldEnd=windowOldPos+windowOldLength;
+        hpatch_StreamPos_t reuseLen,reuseOff,noOverlapLeft;
+        _compute_window_overlap(lastOldPos,lastOldEnd,windowOldPos,windowOldEnd,&reuseLen,&reuseOff,&noOverlapLeft);
+        memmove(oldBuf+(size_t)noOverlapLeft,oldBuf+(size_t)reuseOff,(size_t)reuseLen);
+        if ((noOverlapLeft>0)&&(!oldData->read(oldData,windowOldPos,oldBuf,oldBuf+(size_t)noOverlapLeft)))
+            return _hpatch_FALSE;
+        if ((noOverlapLeft+reuseLen<windowOldLength)&&(!oldData->read(oldData,windowOldPos+noOverlapLeft+reuseLen,
+                            oldBuf+(size_t)(noOverlapLeft+reuseLen),oldBuf+(size_t)windowOldLength)))
+            return _hpatch_FALSE;
+        *pLastOldPos=windowOldPos;
+        *pLastOldEnd=windowOldPos+windowOldLength;
+        return hpatch_TRUE;
+    }
+
+    static hpatch_BOOL _read_meta_batch(TStreamCacheClip* clip,hpatch_StreamPos_t* pLastOldPos,
+                                        hpatch_StreamPos_t maxWindowOldSize,hpatch_StreamPos_t oldSize,
+                                        _oldwin_info_t* winInfos,hpatch_size_t writeIdx,hpatch_size_t batchSize){
+        hpatch_StreamPos_t lastOldPos=*pLastOldPos;
+        hpatch_size_t i;
+        for (i=0;i<batchSize;++i){
+            hpatch_StreamPos_t len;
+            _clip_unpackUIntTo(&len,clip);
+            if (!_read_sign_pos_byLastPos(clip,&lastOldPos)) return _hpatch_FALSE;
+#if (defined __RUN_MEM_SAFE_CHECK)
+            if (len>maxWindowOldSize) return _hpatch_FALSE;
+            if (len!=(hpatch_StreamPos_t)(hpatch_size_t)len) return _hpatch_FALSE;
+            if (lastOldPos>oldSize) return _hpatch_FALSE;
+            if (lastOldPos+len>oldSize) return _hpatch_FALSE;
+#endif
+            winInfos[writeIdx+i].len=len;
+            winInfos[writeIdx+i].oldPos=lastOldPos;
+            lastOldPos+=len;
+        }
+        *pLastOldPos=lastOldPos;
+        return hpatch_TRUE;
+    }
+    
+    static hpatch_BOOL _readForSkipStream(const hpatch_TStreamInput* stream,hpatch_StreamPos_t readPos,
+                                          hpatch_StreamPos_t readEndPos,unsigned char* temp_cache,unsigned char* temp_cacheEnd){
+        while (readPos<readEndPos){
+            hpatch_StreamPos_t rlen=readEndPos-readPos;
+            rlen=(rlen<(size_t)(temp_cacheEnd-temp_cache))?rlen:(size_t)(temp_cacheEnd-temp_cache);
+            if (!stream->read(stream,readPos,temp_cache,temp_cache+(size_t)rlen))
+                return _hpatch_FALSE;
+            readPos+=rlen;
+        }
+        return hpatch_TRUE;
+    }
+
+    static hpatch_inline hpatch_BOOL _read_sub_cover_count(TStreamCacheClip* clip,
+                                        hpatch_StreamPos_t maxSubCoverCount,hpatch_StreamPos_t* out_subCoverCount){
+        _clip_unpackUIntTo(out_subCoverCount,clip);
+    #if (defined __RUN_MEM_SAFE_CHECK)
+        if ((*out_subCoverCount)>maxSubCoverCount) return _hpatch_FALSE;
+    #endif
+        return hpatch_TRUE;
+    }
+
+static hpatch_BOOL _patch_window_diff(const hpatch_TStreamOutput* out_newData,const hpatch_TStreamInput* oldData,
+                                      const hpatch_TStreamInput* diffStream,hpatch_StreamPos_t diffData_pos,
+                                      const hpatch_windowDiffInfo* diffInfo,hpatch_TDecompress* decompressPlugin,
+                                      hpatch_TChecksum* checksumPlugin,hpatch_checksumHandle checksumHandle_old,
+                                      unsigned char* temp_cache,unsigned char* temp_cache_end,
+                                      size_t maxThreadNum,hpatchMTSets_t hpatchMTSets){
+    const hpatch_size_t    windowOldBufSize=(hpatch_size_t)diffInfo->maxWindowOldSize;
+    const hpatch_size_t    stepMemSize=(hpatch_size_t)diffInfo->maxStepMemSize;
+    const hpatch_StreamPos_t windowCount=diffInfo->windowCount;
+    const hpatch_StreamPos_t metaCount=diffInfo->windowMetaCount;
+    unsigned char*         oldBuf;
+    TStreamCacheClip       mainClip;
+    _TOutStreamCache       outCache;
+    hpatch_StreamPos_t     lastOldPos=0;
+    hpatch_StreamPos_t     lastOldEnd=0;
+    hpatch_StreamPos_t     lastOldPosForMeta=0;  // running oldPos for delta decoding
+    hpatch_StreamPos_t     loadedMetaEnd=0;
+    _oldwin_info_t         winInfos[hpatch_kMaxWindowMetaCount];
+    hpatch_StreamPos_t     wi;
+    hpatch_BOOL            result=hpatch_TRUE;
+
+    hpatch_BOOL            isNeedOutCache=hpatch_TRUE;
+    size_t                 kCacheCount=_kWindowCacheCount;
+    hpatch_size_t          cacheSize;
+    hpatch_TUncompresser_t uncompressedStream={0};
+    hpatch_StreamPos_t     diffData_posEnd;
+
+#if (_HPATCH_IS_USED_MULTITHREAD)
+    struct hpatch_mt_manager_win_t* hpatch_mt_manager=0;
+    struct hcache_window_old_mt_t*  oldCache_mt=0;
+    hpatchMTSets_t                  mtsets;
+    TMem2StreamImport               mem2Import;
+#endif
+    assert(out_newData!=0);
+    assert(out_newData->write!=0);
+    assert(oldData!=0);
+    assert(oldData->read!=0);
+    assert(diffStream!=0);
+    assert(diffStream->read!=0);
+    assert(diffInfo!=0);
+    assert(((checksumHandle_old==0)&&(checksumPlugin==0))||((checksumHandle_old!=0)&&(checksumPlugin!=0)));
+#if (defined __RUN_MEM_SAFE_CHECK)
+    if (diffInfo->maxWindowOldSize!=(hpatch_StreamPos_t)(hpatch_size_t)diffInfo->maxWindowOldSize) return _hpatch_FALSE;
+    if (diffInfo->maxStepMemSize!=(hpatch_StreamPos_t)(hpatch_size_t)diffInfo->maxStepMemSize) return _hpatch_FALSE;
+#endif
+
+    if (diffInfo->compressedSize==0){
+        decompressPlugin=0;
+    }else{
+        if (decompressPlugin==0) return _hpatch_FALSE;
+    }
+    diffData_posEnd=(decompressPlugin?diffInfo->compressedSize:diffInfo->uncompressedSize)+diffData_pos;
+#if (defined __RUN_MEM_SAFE_CHECK)
+    if (diffData_posEnd>diffStream->streamSize) return _hpatch_FALSE;
+#endif
+#if (_HPATCH_IS_USED_MULTITHREAD)
+    mtsets=hpatch_getMTSets_win(out_newData->streamSize,oldData->streamSize,diffStream->streamSize-diffData_pos,
+                                decompressPlugin,_kWindowCacheCount,windowOldBufSize,stepMemSize,
+                                (temp_cache_end-temp_cache),maxThreadNum,hpatchMTSets);
+    if (_hpatchMTSets_threadNum(mtsets)>1){
+        isNeedOutCache=!mtsets.writeNew_isMT;
+        kCacheCount=_kWindowCacheCount-(isNeedOutCache?0:1);
+        hpatch_mt_manager=hpatch_mt_manager_win_open(&out_newData,&oldData,&diffStream,&diffData_pos,&diffData_posEnd,
+                                        diffInfo->uncompressedSize,&decompressPlugin,windowCount,windowOldBufSize,
+                                        stepMemSize,&temp_cache,&temp_cache_end,kCacheCount,mtsets);
+        if (!hpatch_mt_manager) { result=_hpatch_FALSE; goto _clear; }
+        oldCache_mt=hpatch_mt_manager_win_oldCache(hpatch_mt_manager);
+    }
+    if (oldCache_mt==0)
+#endif
+    {// Single-threaded: allocate fixed-size oldBuf
+        assert((size_t)(temp_cache_end-temp_cache)>=windowOldBufSize+stepMemSize+hpatch_kStreamCacheSize*kCacheCount);
+        oldBuf=temp_cache; temp_cache+=windowOldBufSize;
+    }
+#if (defined __RUN_MEM_SAFE_CHECK)
+    if ((size_t)(temp_cache_end-temp_cache)<stepMemSize+hpatch_kStreamCacheSize*kCacheCount) { result=_hpatch_FALSE; goto _clear; }
+#endif
+    if (decompressPlugin){
+        if (!compressed_stream_as_uncompressed(&uncompressedStream,diffInfo->uncompressedSize,decompressPlugin,diffStream,
+                                               diffData_pos,diffData_posEnd)) { result=_hpatch_FALSE; goto _clear; }
+        diffStream=&uncompressedStream.base;
+        diffData_pos=0;
+        diffData_posEnd=diffStream->streamSize;
+    }
+
+    if (!_readForSkipStream(diffStream,diffData_pos,       //skip extraData
+                            diffData_pos+diffInfo->extraDataSize,temp_cache,temp_cache_end))
+        { result=_hpatch_FALSE; goto _clear; }
+    diffData_pos+=diffInfo->extraDataSize;
+
+#if (defined __RUN_MEM_SAFE_CHECK)
+    if (diffData_pos>diffData_posEnd) { result=_hpatch_FALSE; goto _clear; }
+    if (diffData_posEnd>diffStream->streamSize) { result=_hpatch_FALSE; goto _clear; }
+#endif
+
+    // Remaining temp_cache for stream caches
+    cacheSize=(hpatch_size_t)((temp_cache_end-temp_cache)-stepMemSize)/kCacheCount;
+    if (cacheSize<hpatch_kStreamCacheSize) { result=_hpatch_FALSE; goto _clear; }
+
+    // Initialize mainClip for reading window data
+    _TStreamCacheClip_init(&mainClip,diffStream,diffData_pos,diffData_posEnd,temp_cache,cacheSize);
+    temp_cache+=cacheSize;
+    //init output cache
+    _TOutStreamCache_init(&outCache,out_newData,isNeedOutCache?temp_cache:0,isNeedOutCache?cacheSize:0);
+    if (isNeedOutCache) temp_cache+=cacheSize;
+
+    //process each window
+    for (wi=0; wi<windowCount; ++wi){
+        hpatch_StreamPos_t subCoverCount;
+        hpatch_StreamPos_t windowOldPos;
+        hpatch_StreamPos_t windowOldLength;
+        hpatch_TStreamInput oldMemStream;
+
+        //after each (metaCount>>1) windows, read next metadata batch
+        if ((((wi)&((metaCount>>1)-1))==0) && (loadedMetaEnd<windowCount)){
+            hpatch_StreamPos_t savedMetaCount=(wi==0)?metaCount:(metaCount>>1);
+            hpatch_size_t      writeIdx=(hpatch_size_t)(loadedMetaEnd & (metaCount-1));
+            hpatch_StreamPos_t batchSize=windowCount-loadedMetaEnd;
+            if (batchSize>savedMetaCount) batchSize=savedMetaCount;
+            if (!_read_meta_batch(&mainClip,&lastOldPosForMeta,diffInfo->maxWindowOldSize,oldData->streamSize,
+                                  winInfos,writeIdx,(hpatch_size_t)batchSize))
+                { result=_hpatch_FALSE; goto _clear; }
+        #if (_HPATCH_IS_USED_MULTITHREAD)
+            if (oldCache_mt)
+                hcache_window_old_prepareBatch(oldCache_mt,(hpatch_size_t)batchSize,winInfos,writeIdx,(hpatch_size_t)metaCount-1);
+        #endif
+            loadedMetaEnd+=batchSize;
+        }
+
+        if (!_read_sub_cover_count(&mainClip,diffInfo->maxSubCoverCount,&subCoverCount))
+            { result=_hpatch_FALSE; goto _clear; }
+        {//look up oldPos/oldLength from ring buffer
+            hpatch_size_t metaIdx=(hpatch_size_t)(wi & (metaCount-1));
+            windowOldPos   =winInfos[metaIdx].oldPos;
+            windowOldLength=winInfos[metaIdx].len;
+        }
+
+        // Load old window data
+#if (_HPATCH_IS_USED_MULTITHREAD)
+        if (oldCache_mt){
+            unsigned char *seg1, *seg1End, *seg2, *seg2End;
+            if (!hcache_window_old_getWindow(oldCache_mt,windowOldPos,windowOldLength,
+                                             &seg1,&seg1End,&seg2,&seg2End))
+                { result=_hpatch_FALSE; goto _clear; }
+            mem2_as_hStreamInput(&oldMemStream,&mem2Import,seg1,seg1End,seg2,seg2End);
+            if (checksumHandle_old!=0){
+                checksumPlugin->append(checksumHandle_old,seg1,seg1End);
+                checksumPlugin->append(checksumHandle_old,seg2,seg2End);
+            }
+        } else
+#endif
+        {
+            if (!_cache_load_window_old(oldData,oldBuf,windowOldPos,windowOldLength, &lastOldPos,&lastOldEnd))
+                { result=_hpatch_FALSE; goto _clear; }
+            if (checksumHandle_old!=0)
+                checksumPlugin->append(checksumHandle_old,oldBuf,oldBuf+(hpatch_size_t)windowOldLength);
+            mem_as_hStreamInput(&oldMemStream,oldBuf,oldBuf+(hpatch_size_t)windowOldLength);
+        }
+
+        if (!_patch_single_stream_loop(&mainClip,&outCache,&oldMemStream,subCoverCount,stepMemSize,
+                                       temp_cache,temp_cache+stepMemSize,cacheSize, 0//no coversListener
+        #if (_IS_NEED_CACHE_OLD_BY_COVERS)
+                                       ,hpatch_FALSE
+        #endif
+                                       ))
+            { result=_hpatch_FALSE; goto _clear; }
+
+#if (_HPATCH_IS_USED_MULTITHREAD)
+        if (oldCache_mt){
+            hcache_window_old_finishWindow(oldCache_mt);
+        }
+#endif
+    }
+
+    //flush and verify
+    if ((!_TOutStreamCache_flush(&outCache))
+      ||(!_TOutStreamCache_isFinish(&outCache))
+      ||(!_TStreamCacheClip_isFinish(&mainClip)))
+        { result=_hpatch_FALSE; goto _clear; }
+
+_clear:
+    if (decompressPlugin)
+        close_compressed_stream_as_uncompressed(&uncompressedStream);
+#if (_HPATCH_IS_USED_MULTITHREAD)
+    if (hpatch_mt_manager){
+        if (!hpatch_mt_manager_win_close(hpatch_mt_manager,!result))
+            result=_hpatch_FALSE;
+        hpatch_mt_manager=0;
+    }
+#endif
+    return result;
+}
+
+
+    //checksum stream wrappers
+    typedef struct _TChecksumInputStream{
+        hpatch_TStreamInput         base;
+        const hpatch_TStreamInput*  realIn;
+        hpatch_TChecksum*           checksumPlugin;
+        hpatch_checksumHandle       checksumHandle;
+		hpatch_StreamPos_t          readedEndPos;
+    } _TChecksumInputStream;
+
+    static hpatch_BOOL _TChecksumInputStream_read(const hpatch_TStreamInput* stream,hpatch_StreamPos_t readFromPos,
+                                                  unsigned char* out_data,unsigned char* out_data_end){
+        _TChecksumInputStream* self=(_TChecksumInputStream*)stream->streamImport;
+        if (!self->realIn->read(self->realIn,readFromPos,out_data,out_data_end))
+            return _hpatch_FALSE;
+        self->checksumPlugin->append(self->checksumHandle,out_data,out_data_end);
+        self->readedEndPos=readFromPos+(out_data_end-out_data);
+        return hpatch_TRUE;
+    }
+
+    static void _TChecksumInputStream_init(_TChecksumInputStream* self,const hpatch_TStreamInput* realIn,
+                                           hpatch_TChecksum* checksumPlugin,hpatch_checksumHandle checksumHandle){
+        assert(self);
+        assert(realIn);
+        assert(checksumPlugin);
+        assert(checksumHandle);
+        self->realIn=realIn;
+        self->checksumPlugin=checksumPlugin;
+        self->checksumHandle=checksumHandle;
+        self->readedEndPos=0;
+        self->base.streamImport=self;
+        self->base.streamSize=realIn->streamSize;
+        self->base.read=_TChecksumInputStream_read;
+    }
+
+    typedef struct _TChecksumOutputStream{
+        hpatch_TStreamOutput        base;
+        const hpatch_TStreamOutput* realOut;
+        hpatch_TChecksum*           checksumPlugin;
+        hpatch_checksumHandle       checksumHandle;
+		hpatch_StreamPos_t          writedEndPos;
+    } _TChecksumOutputStream;
+
+    static hpatch_BOOL _TChecksumOutputStream_write(const hpatch_TStreamOutput* stream,
+                                                    hpatch_StreamPos_t writeToPos,
+                                                    const unsigned char* data,const unsigned char* data_end){
+        _TChecksumOutputStream* self=(_TChecksumOutputStream*)stream->streamImport;
+        if (!self->realOut->write(self->realOut,writeToPos,data,data_end))
+            return _hpatch_FALSE;
+        self->checksumPlugin->append(self->checksumHandle,data,data_end);
+        self->writedEndPos=writeToPos+(data_end-data);
+        return hpatch_TRUE;
+    }
+
+    static void _TChecksumOutputStream_init(_TChecksumOutputStream* self,const hpatch_TStreamOutput* realOut,
+                                            hpatch_TChecksum* checksumPlugin,hpatch_checksumHandle checksumHandle){
+        assert(self);
+        assert(realOut);
+        assert(checksumPlugin);
+        assert(checksumHandle);
+        self->realOut=realOut;
+        self->checksumPlugin=checksumPlugin;
+        self->checksumHandle=checksumHandle;
+        self->writedEndPos=0;
+        self->base.streamImport=self;
+        self->base.streamSize=realOut->streamSize;
+        self->base.write=_TChecksumOutputStream_write;
+        self->base.read_writed=0;
+    }
+
+TWindowPatchResult patch_window_diff(winpatch_listener_t* listener,
+                                     const hpatch_TStreamOutput*  __out_newData,
+                                     const hpatch_TStreamInput*   oldData,
+                                     const hpatch_TStreamInput*   windowDiff,
+                                     hpatch_StreamPos_t diffInfo_pos,size_t threadNum){
+    TWindowPatchResult       result=kWindowPatch_ok;
+	hpatch_BOOL              patch_result;
+    hpatch_windowDiffInfo    diffInfo;
+    hpatch_TDecompress*      decompressPlugin=0;
+    hpatch_TChecksum*        checksumPlugin=0;
+    unsigned char*           temp_cache_back=0;
+    unsigned char*           temp_cache=0;
+    unsigned char*           temp_cacheEnd=0;
+    hpatch_BOOL              isChecksumNew;
+    hpatch_BOOL              isChecksumOld=hpatch_FALSE;
+    hpatch_BOOL              isChecksumDiff=hpatch_FALSE;
+    hpatch_checksumHandle    checksumHandle_old=0;
+    hpatch_checksumHandle    checksumHandle_new=0;
+    hpatch_checksumHandle    checksumHandle_diff=0;
+    hpatch_size_t            checksumByteSize;
+    const hpatch_TStreamInput* effectiveDiffStream;
+    _TChecksumInputStream    checksumDiffInput;
+    _TChecksumOutputStream   checksumNewOutput;
+    const hpatch_TStreamOutput* effectiveOutNew;
+    hpatch_TStreamOutput     _out_newData=*__out_newData;
+    hpatch_TStreamOutput*    out_newData=&_out_newData;
+    hpatch_byte              headerCache[hpatch_kWindowDiffHeadMaxSize];
+    hpatch_size_t            headerSize=sizeof(headerCache);
+
+    assert(listener!=0);
+    assert(listener->onDiffInfo!=0);
+    assert(out_newData->write!=0);
+    assert(oldData!=0);
+    assert(oldData->read!=0);
+    assert(windowDiff!=0);
+    assert(windowDiff->read!=0);
+    
+    if (!_getWindowDiffInfo(&diffInfo,windowDiff,diffInfo_pos,headerCache,&headerSize))//parse header
+        return kWindowPatch_load_head_error;
+    if (diffInfo.newDataSize>out_newData->streamSize)//check output limit
+        return kWindowPatch_new_size_error;
+    out_newData->streamSize=diffInfo.newDataSize;//adjust output stream size
+
+    isChecksumNew=(diffInfo.checksumByteSize>0);
+    if (!listener->onDiffInfo(listener,&diffInfo,&decompressPlugin,&checksumPlugin,
+                              &isChecksumNew,&isChecksumOld,&isChecksumDiff,&temp_cache,&temp_cacheEnd))
+        return kWindowPatch_onDiffInfo_error;
+    if ((temp_cache==0)||(temp_cache>=temp_cacheEnd))
+        return kWindowPatch_temp_mem_error;
+    if (diffInfo.maxWindowOldSize+diffInfo.maxStepMemSize+hpatch_kStreamCacheSize*_kWindowCacheCount>(size_t)(temp_cacheEnd-temp_cache))
+        return kWindowPatch_temp_mem_error;
+    temp_cache_back=temp_cache;
+
+    if ((diffInfo.checksumByteSize>0)&&(isChecksumNew||isChecksumOld||isChecksumDiff)){
+        if ((!checksumPlugin)||(diffInfo.checksumByteSize!=checksumPlugin->checksumByteSize()))
+            return kWindowPatch_checksum_plugin_error;
+        checksumByteSize=(size_t)diffInfo.checksumByteSize;
+    }else{
+        checksumByteSize=0;         checksumPlugin=0;
+        isChecksumNew=hpatch_FALSE; isChecksumOld=hpatch_FALSE; isChecksumDiff=hpatch_FALSE;
+    }
+
+    if (isChecksumOld){
+        checksumHandle_old=checksumPlugin->open(checksumPlugin);
+        if (!checksumHandle_old) { result=kWindowPatch_checksum_open_error; goto clear; }
+        checksumPlugin->begin(checksumHandle_old);
+    }
+    if (isChecksumNew){
+        checksumHandle_new=checksumPlugin->open(checksumPlugin);
+        if (!checksumHandle_new) { result=kWindowPatch_checksum_open_error; goto clear; }
+        checksumPlugin->begin(checksumHandle_new);
+    }
+    if (isChecksumDiff){
+        checksumHandle_diff=checksumPlugin->open(checksumPlugin);
+        if (!checksumHandle_diff) { result=kWindowPatch_checksum_open_error; goto clear; }
+        checksumPlugin->begin(checksumHandle_diff);
+    }
+    
+    if (isChecksumDiff){//wrap diff stream input for checksum
+        _TChecksumInputStream_init(&checksumDiffInput,windowDiff,checksumPlugin,checksumHandle_diff);
+        effectiveDiffStream=&checksumDiffInput.base;
+    }else{
+        effectiveDiffStream=windowDiff;
+    }
+
+    if (isChecksumNew){//wrap new stream output for checksum
+        _TChecksumOutputStream_init(&checksumNewOutput,out_newData,checksumPlugin,checksumHandle_new);
+        effectiveOutNew=&checksumNewOutput.base;
+    }else{
+        effectiveOutNew=out_newData;
+    }
+
+    patch_result=_patch_window_diff(effectiveOutNew,oldData,effectiveDiffStream,diffInfo_pos+diffInfo.windowDataPos,
+                                    &diffInfo,decompressPlugin,checksumHandle_old?checksumPlugin:0,checksumHandle_old,
+                                    temp_cache,temp_cacheEnd, threadNum,hpatchMTSets_full);
+
+    {//verify checksums
+        hpatch_byte* storedChecksumOld=headerCache+diffInfo.windowDataPos-3*checksumByteSize;
+        hpatch_byte* storedChecksumNew=storedChecksumOld+checksumByteSize;
+        hpatch_byte* storedChecksumDiff=storedChecksumNew+checksumByteSize;
+        hpatch_byte* computedChecksum=temp_cache; temp_cache+=checksumByteSize; assert(temp_cache<temp_cacheEnd);
+        hpatch_BOOL  isChecksumNew_and_eq=hpatch_FALSE;
+        if (isChecksumNew){//verify new data checksum
+            checksumPlugin->end(checksumHandle_new,computedChecksum,computedChecksum+checksumByteSize);
+            isChecksumNew_and_eq=(0==memcmp(computedChecksum,storedChecksumNew,checksumByteSize));
+			if (isChecksumNew_and_eq){
+                //assert(patch_result); //why fail?
+                patch_result=hpatch_TRUE;//note: if patch failed, but new data checksum is correct, we can consider it as success.
+            }
+        }
+        if (!isChecksumNew_and_eq){
+            if (isChecksumDiff){//verify diff checksum
+                 //read to diffData end for checksum
+                if (!_readForSkipStream(&checksumDiffInput.base,checksumDiffInput.readedEndPos,
+                                        checksumDiffInput.base.streamSize,temp_cache,temp_cacheEnd))
+                    { result=kWindowPatch_patch_error; goto clear; }
+                checksumPlugin->append(checksumHandle_diff,headerCache,headerCache+headerSize-checksumByteSize);//checksum head
+                checksumPlugin->end(checksumHandle_diff,computedChecksum,computedChecksum+checksumByteSize);
+                if (0!=memcmp(computedChecksum,storedChecksumDiff,checksumByteSize))
+                    { result=kWindowPatch_checksum_diff_error; goto clear; }
+            }
+            if ((!patch_result)&&(diffInfo.oldDataSize!=oldData->streamSize))
+                { result=kWindowPatch_old_size_error; goto clear; }
+            if ((patch_result||(isChecksumNew&&(checksumNewOutput.writedEndPos==diffInfo.newDataSize)))//all old's data checked
+                 &&isChecksumOld){//verify old data checksum
+                checksumPlugin->end(checksumHandle_old,computedChecksum,computedChecksum+checksumByteSize);
+                if (0!=memcmp(computedChecksum,storedChecksumOld,checksumByteSize))
+                    { result=kWindowPatch_checksum_old_error; goto clear; }
+            }
+            if (isChecksumNew) { result=kWindowPatch_checksum_new_error; goto clear; }
+        }
+    }
+    if (!patch_result) { result=kWindowPatch_patch_error; goto clear; }
+
+clear:
+    if (checksumHandle_old!=0) checksumPlugin->close(checksumPlugin,checksumHandle_old);
+    if (checksumHandle_new!=0) checksumPlugin->close(checksumPlugin,checksumHandle_new);
+    if (checksumHandle_diff!=0) checksumPlugin->close(checksumPlugin,checksumHandle_diff);
+    if (listener->onPatchFinish)
+        listener->onPatchFinish(listener,temp_cache_back,temp_cacheEnd);
+    return result;
+}
+