react-native-update 10.34.1 → 10.34.3

package/harmony/pushy/src/main/cpp/HDiffPatch/_atosize.h

@@ -0,0 +1,127 @@
+//_atosize.h
+//
+/*
+ This is the HDiffPatch copyright.
+
+ Copyright (c) 2012-2017 HouSisong All Rights Reserved.
+
+ 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.
+ */
+#ifndef HDiffPatch_atosize_h
+#define HDiffPatch_atosize_h
+#include "libHDiffPatch/HPatch/patch_types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define _kU64Max (~(hpatch_uint64_t)0)
+hpatch_inline static
+hpatch_BOOL a_to_u64(const char* pnum,size_t slen,hpatch_uint64_t* out_size){
+    const hpatch_uint64_t _kSizeMaxDiv10=_kU64Max/10;
+    const hpatch_uint64_t _kSizeMaxMod10=_kU64Max-_kSizeMaxDiv10*10;
+    hpatch_uint64_t v=0;
+    size_t s;
+    if (slen==0) return hpatch_FALSE;
+    if ((slen>=2)&(pnum[0]=='0')) return hpatch_FALSE;
+    for (s=0; s<slen; ++s) {
+        hpatch_uint64_t c=pnum[s];
+        if (('0'<=c)&(c<='9'))
+            ;//empty ok
+        else
+            return hpatch_FALSE;
+        c-='0';
+        if (v<_kSizeMaxDiv10)
+            ;//empty ok
+        else if ((v>_kSizeMaxDiv10)|(c>_kSizeMaxMod10))
+            return hpatch_FALSE;
+        v=v*10+c;
+    }
+    *out_size=v;
+    return hpatch_TRUE;
+}
+
+hpatch_inline static
+hpatch_BOOL kmg_to_u64(const char* pkmgnum,size_t slen,hpatch_uint64_t* out_size){
+    size_t shl;
+    hpatch_uint64_t v;
+    if (slen==0) return hpatch_FALSE;
+    switch (pkmgnum[slen-1]) {
+        case 'k': case 'K': { shl=10; --slen;} break;
+        case 'm': case 'M': { shl=20; --slen;} break;
+        case 'g': case 'G': { shl=30; --slen;} break;
+        default:            { shl= 0;        } break;
+    }
+    if (!a_to_u64(pkmgnum,slen,&v)) return hpatch_FALSE;
+    if (v>(_kU64Max>>shl)) return hpatch_FALSE;
+    *out_size=v<<shl;
+    return hpatch_TRUE;
+}
+
+
+hpatch_inline static
+hpatch_BOOL a_to_size(const char* pnum,size_t slen,size_t* out_size){
+    hpatch_uint64_t v;
+    if (!a_to_u64(pnum,slen,&v)) return hpatch_FALSE;
+    if ((sizeof(size_t)!=sizeof(hpatch_uint64_t)) && (v!=(size_t)v)) return hpatch_FALSE;
+    *out_size=(size_t)v;
+    return hpatch_TRUE;
+}
+
+hpatch_inline static
+hpatch_BOOL kmg_to_size(const char* pkmg_num,size_t slen,size_t* out_size){
+    hpatch_uint64_t v;
+    if (!kmg_to_u64(pkmg_num,slen,&v)) return hpatch_FALSE;
+    if ((sizeof(size_t)!=sizeof(hpatch_uint64_t)) && (v!=(size_t)v)) return hpatch_FALSE;
+    *out_size=(size_t)v;
+    return hpatch_TRUE;
+}
+
+#define          _u64_to_a_kMaxLen   21
+static const char*  _i09_to_one_a_="0123456789";
+
+hpatch_inline static
+char* u64_to_enough_a(hpatch_uint64_t size,char temp_buf_enough[_u64_to_a_kMaxLen]){
+    char* out_a=temp_buf_enough+_u64_to_a_kMaxLen;
+    *(--out_a)='\0';
+    do{
+        hpatch_uint64_t nsize=size/10;
+        *(--out_a)=_i09_to_one_a_[size-nsize*10];
+        size=nsize;
+    }while(size);
+    return out_a;
+}
+
+hpatch_inline static
+hpatch_BOOL u64_to_a(hpatch_uint64_t size,char* out_a,size_t a_buflen){
+    char enough_a[_u64_to_a_kMaxLen];
+    const char* cur_a=u64_to_enough_a(size,enough_a);
+    const size_t datalen=_u64_to_a_kMaxLen-(cur_a-enough_a);
+    if (a_buflen<datalen) return hpatch_FALSE;
+    memcpy(out_a,cur_a,datalen);
+    return hpatch_TRUE;
+}
+
+#ifdef __cplusplus
+}
+#endif
+#endif //HDiffPatch_atosize_h

package/harmony/pushy/src/main/cpp/HDiffPatch/_clock_for_demo.h

@@ -0,0 +1,59 @@
+//_clock_for_demo.h
+// double clock_s()
+/*
+ The MIT License (MIT)
+ Copyright (c) 2012-2017 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.
+ */
+#ifndef HDiffPatch_clock_h
+#define HDiffPatch_clock_h
+
+//  #include <time.h>
+//  static double clock_s(){ return clock()*1.0/CLOCKS_PER_SEC; }
+#ifdef _WIN32
+    #include <windows.h>
+    static double clock_s(){
+        LARGE_INTEGER f;
+        if (QueryPerformanceFrequency(&f)){
+            LARGE_INTEGER c;
+            QueryPerformanceCounter(&c);
+            return c.QuadPart/((double)f.QuadPart);
+        }
+        return GetTickCount64()/1000.0; 
+    }
+#else
+    //Unix-like system
+    #include <sys/time.h>
+    #include <assert.h>
+    static double clock_s(){
+        struct timeval t={0,0};
+        int ret=gettimeofday(&t,0);
+        assert(ret==0);
+        if (ret==0)
+            return t.tv_sec + t.tv_usec/1000000.0;
+        else
+            return 0;
+    }
+#endif
+
+#endif //HDiffPatch_clock_h

package/harmony/pushy/src/main/cpp/HDiffPatch/_dir_ignore.h

@@ -0,0 +1,191 @@
+//  _dir_ignore.h
+//  hdiffz
+//  Created by housisong on 2019-09-30.
+//
+/*
+ The MIT License (MIT)
+ Copyright (c) 2012-2019 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.
+ */
+#ifndef _dir_ignore_h
+#define _dir_ignore_h
+#include <vector>
+#include <string>
+#include <algorithm>
+#include "dirDiffPatch/dir_patch/dir_patch.h"
+
+#if (_IS_NEED_DIR_DIFF_PATCH)
+static void formatIgnorePathName(std::string& path_utf8){
+    for (size_t i=0;i<path_utf8.size();++i) {
+        char c=path_utf8[i];
+        if ((c=='\\')||(c=='/'))
+            path_utf8[i]=kPatch_dirSeparator;
+#ifdef _WIN32
+        else if (isascii(c))
+            path_utf8[i]=(char)tolower(c);
+#endif
+    }
+}
+
+#ifdef _WIN32
+static const char _private_kIgnoreMagicChar = '?';  //a char not used in path name on WIN32
+#else
+static const char _private_kIgnoreMagicChar = ':';  //a char not used in path name
+#endif
+static void _formatIgnorePathSet(std::string& path_utf8){
+    formatIgnorePathName(path_utf8);
+    size_t insert=0;
+    size_t i=0;
+    while (i<path_utf8.size()) {
+        char c=path_utf8[i];
+        if (c=='*'){
+            if ((i+1<path_utf8.size())&&(path_utf8[i+1]==':')){ // *: as *
+                path_utf8[insert++]=c; i+=2; //skip *:
+            }else{
+                path_utf8[insert++]=_private_kIgnoreMagicChar; ++i; //skip *
+            }
+        }else{
+            path_utf8[insert++]=c; ++i;  //skip c
+        }
+    }
+    path_utf8.resize(insert);
+}
+
+static hpatch_BOOL _getIgnorePathSetList(std::vector<std::string>& out_pathList,const char* plist){
+    std::string cur;
+    while (true) {
+        char c=*plist;
+        if ((c=='#')&&(plist[1]==':')){ // #: as #
+            cur.push_back(c); plist+=2; //skip #:
+        }else if ((c=='*')&&(plist[1]==':')){ // *: as *:
+            cur.push_back(c); cur.push_back(':'); plist+=2; //skip *:
+        }else if ((c=='\0')||((c=='#')&&(plist[1]!=':'))){
+            if (cur.empty()) return hpatch_FALSE;// can't empty
+            if (std::string::npos!=cur.find("**")) return hpatch_FALSE;// can't **
+            _formatIgnorePathSet(cur);
+            out_pathList.push_back(cur);
+            if (c=='\0') return hpatch_TRUE;
+            cur.clear();  ++plist; //skip #
+        }else if (c==_private_kIgnoreMagicChar){
+            return hpatch_FALSE; //error path char
+        }else{
+            cur.push_back(c); ++plist; //skip c
+        }
+    }
+}
+
+static bool _matchIgnore(const char* beginS,const char* endS,
+                         const std::vector<const char*>& matchs,size_t mi,
+                         const char* ignoreBegin,const char* ignoreEnd){
+    //O(n*n) !
+    const char* match   =matchs[mi];
+    const char* matchEnd=matchs[mi+1];
+    const char* curS=beginS;
+    while (curS<endS){
+        const char* found=std::search(curS,endS,match,matchEnd);
+        if (found==endS) return false;
+        bool isMatched=true;
+        //check front
+        if (beginS<found){
+            if (mi>0){ //[front match]*[cur match]
+                for (const char* it=beginS;it<found; ++it) {
+                    if ((*it)==kPatch_dirSeparator) { isMatched=false; break; }
+                }
+            }else{ // ?[first match]
+                if ((match==ignoreBegin)&&(match[0]!=kPatch_dirSeparator)&&(found[-1]!=kPatch_dirSeparator))
+                    isMatched=false;
+            }
+        }
+        const char* foundEnd=found+(matchEnd-match);
+        //check back
+        if (isMatched && (mi+2>=matchs.size()) && (foundEnd<endS)){ //[last match]
+            if ((matchEnd==ignoreEnd)&&(matchEnd[-1]!=kPatch_dirSeparator)&&(foundEnd[0]!=kPatch_dirSeparator))
+                isMatched=false;
+        }
+        if (isMatched && (mi+2<matchs.size())
+            && (!_matchIgnore(foundEnd,endS,matchs,mi+2,ignoreBegin,ignoreEnd)))
+            isMatched=false;
+        if (isMatched) return true;
+        curS=found+1;//continue
+    }
+    return false;
+}
+
+static bool isMatchIgnore(const std::string& subPath,const std::string& ignore){
+    assert(!ignore.empty());
+    std::vector<const char*> matchs;
+    const char* beginI=ignore.c_str();
+    const char* endI=beginI+ignore.size();
+    const char* curI=beginI;
+    while (curI<endI) {
+        const char* clip=std::find(curI,endI,_private_kIgnoreMagicChar);
+        if (curI<clip){
+            matchs.push_back(curI);
+            matchs.push_back(clip);
+        }
+        curI=clip+1;
+    }
+    if (matchs.empty()) return true; // WARNING : match any path
+    const char* beginS=subPath.c_str();
+    const char* endS=beginS+subPath.size();
+    return _matchIgnore(beginS,endS,matchs,0,beginI,endI);
+}
+
+static inline bool isMatchIgnoreList(const std::string& subPath,const std::vector<std::string>& ignoreList){
+    for (size_t i=0; i<ignoreList.size(); ++i) {
+        if (isMatchIgnore(subPath,ignoreList[i])) return true;
+    }
+    return false;
+}
+
+struct CDirPathIgnore{
+    CDirPathIgnore(const std::vector<std::string>& ignorePathListBase,
+                   const std::vector<std::string>& ignorePathList,bool isPrintIgnore)
+    :_ignorePathListBase(ignorePathListBase),_ignorePathList(ignorePathList),
+    _isPrintIgnore(isPrintIgnore),_ignoreCount(0){ }
+    CDirPathIgnore(const std::vector<std::string>& ignorePathList,bool isPrintIgnore)
+    :_ignorePathListBase(ignorePathList),_ignorePathList(ignorePathList),
+    _isPrintIgnore(isPrintIgnore),_ignoreCount(0){ }
+    bool isNeedIgnore(const std::string& path,size_t rootPathNameLen){
+        std::string subPath(path.begin()+rootPathNameLen,path.end());
+        formatIgnorePathName(subPath);
+        bool result=   isMatchIgnoreList(subPath,_ignorePathListBase);
+        if ((!result)&&(&_ignorePathListBase!=&_ignorePathList))
+            result=isMatchIgnoreList(subPath,_ignorePathList);
+        if (result) ++_ignoreCount;
+        if (result&&_isPrintIgnore){ //printf
+            printf("  ignore file : \"");
+            hpatch_printPath_utf8(path.c_str());  printf("\"\n");
+        }
+        return result;
+    }
+    inline size_t ignoreCount()const{ return _ignoreCount; }
+private:
+    const std::vector<std::string>& _ignorePathListBase;
+    const std::vector<std::string>& _ignorePathList;
+    const bool                      _isPrintIgnore;
+    size_t                          _ignoreCount;
+};
+#endif
+
+#endif // dir_ignore_h

package/harmony/pushy/src/main/cpp/HDiffPatch/_hextobytes.h

@@ -0,0 +1,112 @@
+//_hextobytes.h
+//
+/*
+ This is the HDiffPatch copyright.
+
+ Copyright (c) 2018-2025 HouSisong All Rights Reserved.
+
+ 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.
+ */
+#ifndef HDiffPatch_hextobytes_h
+#define HDiffPatch_hextobytes_h
+#include "libHDiffPatch/HPatch/patch_types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+static const char _halfbyte_to_hex1[16]={'0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f'};
+static const char _halfbyte_to_HEX1[16]={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
+
+hpatch_inline static
+void byte_to_hex2(hpatch_byte b,char out_hex2[2]){
+    out_hex2[0]=_halfbyte_to_hex1[b>>4]; //h
+    out_hex2[1]=_halfbyte_to_hex1[b&0xF];//l
+}
+hpatch_inline static
+void byte_to_HEX2(hpatch_byte b,char out_HEX2[2]){
+    out_HEX2[0]=_halfbyte_to_HEX1[b>>4]; //h
+    out_HEX2[1]=_halfbyte_to_HEX1[b&0xF];//l
+}
+
+//out_hexs must have enough space for 2*blen
+hpatch_inline static
+void bytes_to_hexs(const hpatch_byte* bytes,hpatch_size_t blen,char* out_hexs){
+    size_t i;
+    for (i=0; i<blen; ++i)
+        byte_to_hex2(bytes[i],&out_hexs[i*2]);
+}
+hpatch_inline static
+void bytes_to_HEXs(const hpatch_byte* bytes,hpatch_size_t blen,char* out_HEXs){
+    size_t i;
+    for (i=0; i<blen; ++i)
+        byte_to_HEX2(bytes[i],&out_HEXs[i*2]);
+}
+
+static const unsigned char _hex1_to_halfbyte[256] = {
+    0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF, 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+    0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF, 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+    0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF, 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+    0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07, 0x08,0x09,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF, //0-9
+    0xFF,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F,0xFF, 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF, //A-F
+    0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF, 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+    0xFF,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,0xFF, 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF, //a-f
+    0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF, 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+    0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF, 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+    0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF, 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+    0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF, 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+    0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF, 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+    0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF, 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+    0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF, 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+    0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF, 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+    0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF, 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+};
+
+#define __private_hex2_to_byte(hex_0,hex_1,rb)  \
+    hpatch_byte h=_hex1_to_halfbyte[(unsigned char)(hex_0)];    \
+    hpatch_byte l=_hex1_to_halfbyte[(unsigned char)(hex_1)];    \
+    (rb)=(hpatch_byte)((h<<4)|l);
+
+hpatch_inline static
+hpatch_BOOL hex2_to_byte(const char hex2[2],hpatch_byte* out_b){
+    __private_hex2_to_byte(hex2[0],hex2[1],*out_b);
+    return ((h|l) <= 0xF);
+}
+
+//hexStrLen must be even, out_bytes must have enough space for hexStrLen/2 bytes
+hpatch_inline static
+hpatch_BOOL hexs_to_bytes(const char* hexs,hpatch_size_t hexStrLen,hpatch_byte* out_bytes){
+    hpatch_size_t i;
+    hpatch_size_t blen=hexStrLen>>1;
+    hpatch_byte check=0;
+    assert((hexStrLen&1)==0);
+    for (i=0; i<blen; ++i){
+        __private_hex2_to_byte(hexs[i*2],hexs[i*2+1],out_bytes[i]);
+        check|=h; check|=l;
+    }
+    return (check <= 0xF);
+}
+
+#ifdef __cplusplus
+}
+#endif
+#endif //HDiffPatch_hextobytes_h