_ZNK4Ogre10DataStream4sizeEv:
  186|    637|        size_t size(void) const { return mSize; }

_ZN4Ogre13OptimisedUtilC2Ev:
   64|      2|        OptimisedUtil(void) {}

_ZNK4Ogre9SharedPtrINS_10DataStreamEEptEv:
   63|  1.27k|        T* operator->() const { return shared_ptr<T>::operator->(); }

_ZN4Ogre14ArchiveManager12getSingletonEv:
   40|      1|    {  
   41|       |        assert( msSingleton );  return ( *msSingleton );  
   42|      1|    }
_ZN4Ogre14ArchiveManagerC2Ev:
   45|      1|    {
   46|      1|    }
_ZN4Ogre14ArchiveManager17addArchiveFactoryEPNS_14ArchiveFactoryE:
  126|      1|    {
  127|      1|        mArchFactories.emplace(factory->getType(), factory);
  128|      1|        LogManager::getSingleton().logMessage("ArchiveFactory for type '" + factory->getType() + "' registered");
  129|      1|    }

_ZN4Ogre16MemoryDataStreamC2EPvmbb:
  190|  3.75k|        : DataStream(static_cast<uint16>(readOnly ? READ : (READ | WRITE)))
  ------------------
  |  Branch (190:42): [True: 0, False: 3.75k]
  ------------------
  191|  3.75k|    {
  192|  3.75k|        mData = mPos = static_cast<uchar*>(pMem);
  193|  3.75k|        mSize = inSize;
  194|  3.75k|        mEnd = mData + mSize;
  195|  3.75k|        mFreeOnClose = freeOnClose;
  196|       |        assert(mEnd >= mPos);
  197|  3.75k|    }
_ZN4Ogre16MemoryDataStreamC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEmbb:
  327|  2.45k|        : DataStream(name, static_cast<uint16>(readOnly ? READ : (READ | WRITE)))
  ------------------
  |  Branch (327:48): [True: 2.45k, False: 0]
  ------------------
  328|  2.45k|    {
  329|  2.45k|        mSize = inSize;
  330|  2.45k|        mData = OGRE_ALLOC_T(uchar, mSize, MEMCATEGORY_GENERAL);
  331|  2.45k|        mPos = mData;
  332|  2.45k|        mEnd = mData + mSize;
  333|  2.45k|        mFreeOnClose = freeOnClose;
  334|       |        assert(mEnd >= mPos);
  335|  2.45k|    }
_ZN4Ogre16MemoryDataStreamD2Ev:
  338|  6.21k|    {
  339|  6.21k|        close();
  340|  6.21k|    }
_ZN4Ogre16MemoryDataStream4readEPvm:
  343|    637|    {
  344|       |        // Read over end of memory?
  345|    637|        if (mPos >= mEnd)
  ------------------
  |  Branch (345:13): [True: 78, False: 559]
  ------------------
  346|     78|            return 0;
  347|    559|        size_t cnt = std::min(count, static_cast<size_t>(mEnd - mPos));
  348|    559|        if (cnt == 0)
  ------------------
  |  Branch (348:13): [True: 0, False: 559]
  ------------------
  349|      0|            return 0;
  350|       |
  351|    559|        assert (cnt<=count);
  352|       |
  353|    559|        memcpy(buf, mPos, cnt);
  354|    559|        mPos += cnt;
  355|    559|        return cnt;
  356|    559|    }
_ZN4Ogre16MemoryDataStream5closeEv:
  460|  6.21k|    {
  461|  6.21k|        mAccess = 0;
  462|  6.21k|        if (mFreeOnClose && mData)
  ------------------
  |  Branch (462:13): [True: 2.45k, False: 3.75k]
  |  Branch (462:29): [True: 2.45k, False: 0]
  ------------------
  463|  2.45k|        {
  464|       |            OGRE_FREE(mData, MEMCATEGORY_GENERAL);
  465|  2.45k|            mData = 0;
  466|  2.45k|        }
  467|  6.21k|    }

_ZN4Ogre9ExceptionC2EiRKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_PKcSB_l:
   43|  2.70k|        line( lin ),
   44|  2.70k|        typeName(typ),
   45|  2.70k|        description( desc ),
   46|  2.70k|        source( src ),
   47|  2.70k|        file( fil )
   48|  2.70k|    {
   49|  2.70k|        StringStream ss;
   50|       |
   51|  2.70k|        ss << typeName << ": "
   52|  2.70k|           << description
   53|  2.70k|           << " in " << source;
   54|       |
   55|  2.70k|        if( line > 0 )
  ------------------
  |  Branch (55:13): [True: 2.70k, False: 0]
  ------------------
   56|  2.70k|        {
   57|  2.70k|            ss << " at " << file << " (line " << line << ")";
   58|  2.70k|        }
   59|       |
   60|  2.70k|        fullDesc = ss.str();
   61|  2.70k|    }

_ZN4Ogre3LogC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEbb:
   52|      1|        mLogLevel(LML_NORMAL), mDebugOut(debuggerOutput),
   53|      1|        mSuppressFile(suppressFile), mTimeStamp(true), mLogName(name), mTermHasColours(false)
   54|      1|    {
   55|      1|        if (!mSuppressFile)
  ------------------
  |  Branch (55:13): [True: 0, False: 1]
  ------------------
   56|      0|        {
   57|      0|            mLog.open(name.c_str());
   58|       |
   59|       |#if (OGRE_PLATFORM == OGRE_PLATFORM_WIN32 || OGRE_PLATFORM == OGRE_PLATFORM_WINRT) && _WIN32_WINNT >= _WIN32_WINNT_VISTA
   60|       |            // Register log file to be collected by Windows Error Reporting
   61|       |            const int utf16Length = ::MultiByteToWideChar(CP_ACP, 0, name.c_str(), (int)name.size(), NULL, 0);
   62|       |            if(utf16Length > 0)
   63|       |            {
   64|       |                std::wstring wname;
   65|       |                wname.resize(utf16Length);
   66|       |                if (0 != ::MultiByteToWideChar(CP_ACP, 0, name.c_str(), (int)name.size(), &wname[0], (int)wname.size()))
   67|       |                    WerRegisterFile(wname.c_str(), WerRegFileTypeOther, WER_FILE_ANONYMOUS_DATA);
   68|       |            }
   69|       |#endif
   70|      0|        }
   71|       |
   72|      1|#if OGRE_PLATFORM != OGRE_PLATFORM_WINRT
   73|      1|        char* val = getenv("OGRE_MIN_LOGLEVEL");
   74|      1|        int min_lml;
   75|      1|        if(val && StringConverter::parse(val, min_lml))
  ------------------
  |  Branch (75:12): [True: 0, False: 1]
  |  Branch (75:12): [True: 0, False: 1]
  |  Branch (75:19): [True: 0, False: 0]
  ------------------
   76|      0|            setMinLogLevel(LogMessageLevel(min_lml));
   77|       |
   78|      1|        if(mDebugOut)
  ------------------
  |  Branch (78:12): [True: 0, False: 1]
  ------------------
   79|      0|        {
   80|      0|            val = getenv("TERM");
   81|      0|            mTermHasColours = val && String(val).find("xterm") != String::npos;
  ------------------
  |  Branch (81:31): [True: 0, False: 0]
  |  Branch (81:38): [True: 0, False: 0]
  ------------------
   82|      0|        }
   83|      1|#endif
   84|      1|    }
_ZN4Ogre3Log10logMessageERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_15LogMessageLevelEb:
   97|      4|    {
   98|      4|        OGRE_LOCK_AUTO_MUTEX;
   99|      4|        if (lml >= mLogLevel)
  ------------------
  |  Branch (99:13): [True: 0, False: 4]
  ------------------
  100|      0|        {
  101|      0|            bool skipThisMessage = false;
  102|      0|            for(auto & l : mListeners)
  ------------------
  |  Branch (102:26): [True: 0, False: 0]
  ------------------
  103|      0|                l->messageLogged( message, lml, maskDebug, mLogName, skipThisMessage);
  104|       |            
  105|      0|            if (!skipThisMessage)
  ------------------
  |  Branch (105:17): [True: 0, False: 0]
  ------------------
  106|      0|            {
  107|      0|                if (mDebugOut && !maskDebug)
  ------------------
  |  Branch (107:21): [True: 0, False: 0]
  |  Branch (107:34): [True: 0, False: 0]
  ------------------
  108|      0|                {
  109|       |#    if (OGRE_PLATFORM == OGRE_PLATFORM_WIN32 || OGRE_PLATFORM == OGRE_PLATFORM_WINRT) && OGRE_DEBUG_MODE
  110|       |                    OutputDebugStringA("Ogre: ");
  111|       |                    OutputDebugStringA(message.c_str());
  112|       |                    OutputDebugStringA("\n");
  113|       |#    endif
  114|       |
  115|      0|                    std::ostream& os = int(lml) >= int(LML_WARNING) ? std::cerr : std::cout;
  ------------------
  |  Branch (115:40): [True: 0, False: 0]
  ------------------
  116|       |
  117|      0|                    if(mTermHasColours) {
  ------------------
  |  Branch (117:24): [True: 0, False: 0]
  ------------------
  118|      0|                        if(lml == LML_WARNING)
  ------------------
  |  Branch (118:28): [True: 0, False: 0]
  ------------------
  119|      0|                            os << YELLOW;
  120|      0|                        if(lml == LML_CRITICAL)
  ------------------
  |  Branch (120:28): [True: 0, False: 0]
  ------------------
  121|      0|                            os << RED;
  122|      0|                    }
  123|       |
  124|      0|                    os << message;
  125|       |
  126|      0|                    if(mTermHasColours) {
  ------------------
  |  Branch (126:24): [True: 0, False: 0]
  ------------------
  127|      0|                        os << RESET;
  128|      0|                    }
  129|       |
  130|      0|                    os << std::endl;
  131|      0|                }
  132|       |
  133|       |                // Write time into log
  134|      0|                if (!mSuppressFile)
  ------------------
  |  Branch (134:21): [True: 0, False: 0]
  ------------------
  135|      0|                {
  136|      0|                    if (mTimeStamp)
  ------------------
  |  Branch (136:25): [True: 0, False: 0]
  ------------------
  137|      0|                    {
  138|      0|                        auto t = std::time(nullptr);
  139|      0|                        auto pTime = std::localtime(&t);
  140|      0|                        mLog << std::put_time(pTime, "%H:%M:%S: ");
  141|      0|                    }
  142|      0|                    mLog << message << std::endl;
  143|       |
  144|       |                    // Flush stcmdream to ensure it is written (incase of a crash, we need log to be up to date)
  145|      0|                    mLog.flush();
  146|      0|                }
  147|      0|            }
  148|      0|        }
  149|      4|    }
_ZN4Ogre3Log14setMinLogLevelENS_15LogMessageLevelE:
  173|      1|    {
  174|      1|        OGRE_LOCK_AUTO_MUTEX;
  175|      1|        mLogLevel = lml;
  176|      1|    }

_ZN4Ogre10LogManager12getSingletonEv:
   39|      4|    {  
   40|       |        assert( msSingleton );  return ( *msSingleton );  
   41|      4|    }
_ZN4Ogre10LogManagerC2Ev:
   44|      1|    {
   45|       |        mDefaultLog = NULL;
   46|      1|    }
_ZN4Ogre10LogManager9createLogERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEbbb:
   61|      1|    {
   62|      1|        OGRE_LOCK_AUTO_MUTEX;
   63|       |
   64|      1|        Log* newLog = OGRE_NEW Log(name, debuggerOutput, suppressFileOutput);
   65|       |
   66|      1|        if( !mDefaultLog || defaultLog )
  ------------------
  |  Branch (66:13): [True: 1, False: 0]
  |  Branch (66:29): [True: 0, False: 0]
  ------------------
   67|      1|        {
   68|      1|            mDefaultLog = newLog;
   69|      1|        }
   70|       |
   71|      1|        mLogs.emplace(name, newLog);
   72|       |
   73|      1|        return newLog;
   74|      1|    }
_ZN4Ogre10LogManager10logMessageERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_15LogMessageLevelEb:
  125|      4|    {
  126|      4|        OGRE_LOCK_AUTO_MUTEX;
  127|      4|        if (mDefaultLog)
  ------------------
  |  Branch (127:13): [True: 4, False: 0]
  ------------------
  128|      4|        {
  129|      4|            mDefaultLog->logMessage(message, lml, maskDebug);
  130|      4|        }
  131|      4|    }
_ZN4Ogre10LogManager14setMinLogLevelENS_15LogMessageLevelE:
  155|      1|    {
  156|      1|        OGRE_LOCK_AUTO_MUTEX;
  157|      1|        if (mDefaultLog)
  ------------------
  |  Branch (157:13): [True: 1, False: 0]
  ------------------
  158|      1|        {
  159|      1|            mDefaultLog->setMinLogLevel(lml);
  160|      1|        }
  161|      1|    }

_ZN4Ogre13OptimisedUtil21_detectImplementationEv:
  326|      2|    {
  327|       |        //
  328|       |        // Some speed test results (averaged number of CPU timestamp (RDTSC) per-function call):
  329|       |        //
  330|       |        //   Dagon SkeletonAnimation sample - softwareVertexSkinning:
  331|       |        //
  332|       |        //                                      Pentium 4 3.0G HT       Athlon XP 2500+     Athlon 64 X2 Dual Core 3800+
  333|       |        //
  334|       |        //      Shared Buffers, General C       763677                  462903              473038
  335|       |        //      Shared Buffers, Unrolled SSE    210030 *best*           369762              228328 *best*
  336|       |        //      Shared Buffers, General SSE     286202                  352412 *best*       302796
  337|       |        //
  338|       |        //      Separated Buffers, General C    762640                  464840              478740
  339|       |        //      Separated Buffers, Unrolled SSE 219222 *best*           287992 *best*       238770 *best*
  340|       |        //      Separated Buffers, General SSE  290129                  341614              307262
  341|       |        //
  342|       |        //      PosOnly, General C              388663                  257350              262831
  343|       |        //      PosOnly, Unrolled SSE           139814 *best*           200323 *best*       168995 *best*
  344|       |        //      PosOnly, General SSE            172693                  213704              175447
  345|       |        //
  346|       |        //   Another my own test scene - softwareVertexSkinning:
  347|       |        //
  348|       |        //                                      Pentium P4 3.0G HT      Athlon XP 2500+
  349|       |        //
  350|       |        //      Shared Buffers, General C       74527                   -
  351|       |        //      Shared Buffers, Unrolled SSE    22743 *best*            -
  352|       |        //      Shared Buffers, General SSE     28527                   -
  353|       |        //
  354|       |        //
  355|       |        // Note that speed test appears unaligned load/store instruction version
  356|       |        // loss performance 5%-10% than aligned load/store version, even if both
  357|       |        // of them access to aligned data. Thus, we should use aligned load/store
  358|       |        // as soon as possible.
  359|       |        //
  360|       |        //
  361|       |        // We are pick up the implementation based on test results above.
  362|       |        //
  363|       |#ifdef __DO_PROFILE__
  364|       |        {
  365|       |            static OptimisedUtilProfiler msOptimisedUtilProfiler;
  366|       |            return &msOptimisedUtilProfiler;
  367|       |        }
  368|       |
  369|       |#else   // !__DO_PROFILE__
  370|       |
  371|      2|#if __OGRE_HAVE_SSE
  372|      2|        if (PlatformInformation::getCpuFeatures() & PlatformInformation::CPU_FEATURE_SSE)
  ------------------
  |  Branch (372:13): [True: 2, False: 0]
  ------------------
  373|      2|        {
  374|      2|            return _getOptimisedUtilSSE();
  375|      2|        }
  376|      0|        else
  377|       |#elif __OGRE_HAVE_NEON
  378|       |        if (PlatformInformation::getCpuFeatures() & PlatformInformation::CPU_FEATURE_NEON)
  379|       |        {
  380|       |            return _getOptimisedUtilSSE();
  381|       |        }
  382|       |        else
  383|       |#endif  // __OGRE_HAVE_SSE
  384|      0|        {
  385|      0|            return _getOptimisedUtilGeneral();
  386|      0|        }
  387|       |
  388|      2|#endif  // __DO_PROFILE__
  389|      2|    }

_ZN4Ogre16OptimisedUtilSSEC2Ev:
 1040|      2|        : mPreferGeneralVersionForSharedBuffers(false)
 1041|      2|    {
 1042|       |        // For AMD Athlon XP (but not that for Althon 64), it's prefer to never use
 1043|       |        // unrolled version for shared buffers at all, I guess because that version
 1044|       |        // run out of usable CPU registers, or L1/L2 cache related problem, causing
 1045|       |        // slight performance loss than general version.
 1046|       |        //
 1047|      2|#if __OGRE_HAVE_NEON == 0
 1048|      2|        if (PlatformInformation::getCpuIdentifier().find("AuthenticAMD") != String::npos)
  ------------------
  |  Branch (1048:13): [True: 2, False: 0]
  ------------------
 1049|      2|        {
 1050|       |            // How can I check it's an Athlon XP but not Althon 64?
 1051|       |            // Ok, just test whether supports SSE2/SSE3 or not, if not,
 1052|       |            // assume general version faster than unrolled version :)
 1053|       |            //
 1054|      2|            if (!(PlatformInformation::getCpuFeatures() &
  ------------------
  |  Branch (1054:17): [True: 0, False: 2]
  ------------------
 1055|      2|                (PlatformInformation::CPU_FEATURE_SSE2 | PlatformInformation::CPU_FEATURE_SSE3)))
 1056|      0|            {
 1057|      0|                mPreferGeneralVersionForSharedBuffers = true;
 1058|      0|            }
 1059|      2|        }
 1060|      2|#endif
 1061|      2|    }
_ZN4Ogre20_getOptimisedUtilSSEEv:
 2141|      2|    {
 2142|      2|        static OptimisedUtilSSE msOptimisedUtilSSE;
 2143|       |#if defined(__OGRE_SIMD_ALIGN_STACK)
 2144|       |        static OptimisedUtilWithStackAlign msOptimisedUtilWithStackAlign(&msOptimisedUtilSSE);
 2145|       |        return &msOptimisedUtilWithStackAlign;
 2146|       |#else
 2147|      2|        return &msOptimisedUtilSSE;
 2148|      2|#endif
 2149|      2|    }

_ZN4Ogre19PlatformInformation16getCpuIdentifierEv:
  655|      2|    {
  656|      2|        static const String sIdentifier = _detectCpuIdentifier();
  657|      2|        return sIdentifier;
  658|      2|    }
_ZN4Ogre19PlatformInformation14getCpuFeaturesEv:
  661|      4|    {
  662|      4|        static const uint sFeatures = _detectCpuFeatures();
  663|      4|        return sFeatures;
  664|      4|    }
OgrePlatformInformation.cpp:_ZN4OgreL20_detectCpuIdentifierEv:
  427|      2|    {
  428|       |        // Supports CPUID instruction ?
  429|      2|        if (_isSupportCpuid())
  ------------------
  |  Branch (429:13): [True: 2, False: 0]
  ------------------
  430|      2|        {
  431|      2|            CpuidResult result;
  432|      2|            uint nExIds;
  433|      2|            char CPUString[0x20];
  434|      2|            char CPUBrandString[0x40];
  435|       |
  436|      2|            StringStream detailedIdentStr;
  437|       |
  438|       |
  439|       |            // Has standard feature ?
  440|      2|            if (_performCpuid(0, result))
  ------------------
  |  Branch (440:17): [True: 2, False: 0]
  ------------------
  441|      2|            {
  442|      2|                memset(CPUString, 0, sizeof(CPUString));
  443|      2|                memset(CPUBrandString, 0, sizeof(CPUBrandString));
  444|       |
  445|       |                //*((int*)CPUString) = result._ebx;
  446|       |                //*((int*)(CPUString+4)) = result._edx;
  447|       |                //*((int*)(CPUString+8)) = result._ecx;
  448|      2|                memcpy(CPUString, &result._ebx, sizeof(int));
  449|      2|                memcpy(CPUString+4, &result._edx, sizeof(int));
  450|      2|                memcpy(CPUString+8, &result._ecx, sizeof(int));
  451|       |
  452|      2|                detailedIdentStr << CPUString;
  453|       |
  454|       |                // Calling _performCpuid with 0x80000000 as the query argument
  455|       |                // gets the number of valid extended IDs.
  456|      2|                nExIds = _performCpuid(0x80000000, result);
  457|       |
  458|     70|                for (uint i=0x80000000; i<=nExIds; ++i)
  ------------------
  |  Branch (458:41): [True: 68, False: 2]
  ------------------
  459|     68|                {
  460|     68|                    _performCpuid(i, result);
  461|       |
  462|       |                    // Interpret CPU brand string and cache information.
  463|     68|                    if  (i == 0x80000002)
  ------------------
  |  Branch (463:26): [True: 2, False: 66]
  ------------------
  464|      2|                    {
  465|      2|                        memcpy(CPUBrandString + 0, &result._eax, sizeof(result._eax));
  466|      2|                        memcpy(CPUBrandString + 4, &result._ebx, sizeof(result._ebx));
  467|      2|                        memcpy(CPUBrandString + 8, &result._ecx, sizeof(result._ecx));
  468|      2|                        memcpy(CPUBrandString + 12, &result._edx, sizeof(result._edx));
  469|      2|                    }
  470|     66|                    else if  (i == 0x80000003)
  ------------------
  |  Branch (470:31): [True: 2, False: 64]
  ------------------
  471|      2|                    {
  472|      2|                        memcpy(CPUBrandString + 16 + 0, &result._eax, sizeof(result._eax));
  473|      2|                        memcpy(CPUBrandString + 16 + 4, &result._ebx, sizeof(result._ebx));
  474|      2|                        memcpy(CPUBrandString + 16 + 8, &result._ecx, sizeof(result._ecx));
  475|      2|                        memcpy(CPUBrandString + 16 + 12, &result._edx, sizeof(result._edx));
  476|      2|                    }
  477|     64|                    else if  (i == 0x80000004)
  ------------------
  |  Branch (477:31): [True: 2, False: 62]
  ------------------
  478|      2|                    {
  479|      2|                        memcpy(CPUBrandString + 32 + 0, &result._eax, sizeof(result._eax));
  480|      2|                        memcpy(CPUBrandString + 32 + 4, &result._ebx, sizeof(result._ebx));
  481|      2|                        memcpy(CPUBrandString + 32 + 8, &result._ecx, sizeof(result._ecx));
  482|      2|                        memcpy(CPUBrandString + 32 + 12, &result._edx, sizeof(result._edx));
  483|      2|                    }
  484|     68|                }
  485|       |
  486|      2|                String brand(CPUBrandString);
  487|      2|                StringUtil::trim(brand);
  488|      2|                if (!brand.empty())
  ------------------
  |  Branch (488:21): [True: 2, False: 0]
  ------------------
  489|      2|                    detailedIdentStr << ": " << brand;
  490|       |
  491|      2|                return detailedIdentStr.str();
  492|      2|            }
  493|      2|        }
  494|       |
  495|      0|        return "X86";
  496|      2|    }
OgrePlatformInformation.cpp:_ZN4OgreL13_performCpuidEiRNS_11CpuidResultE:
  151|     82|    {
  152|       |#if OGRE_COMPILER == OGRE_COMPILER_MSVC
  153|       |        int CPUInfo[4];
  154|       |        __cpuid(CPUInfo, query);
  155|       |        result._eax = CPUInfo[0];
  156|       |        result._ebx = CPUInfo[1];
  157|       |        result._ecx = CPUInfo[2];
  158|       |        result._edx = CPUInfo[3];
  159|       |        return result._eax;
  160|       |#elif (OGRE_COMPILER == OGRE_COMPILER_GNUC || OGRE_COMPILER == OGRE_COMPILER_CLANG) && OGRE_PLATFORM != OGRE_PLATFORM_EMSCRIPTEN
  161|       |        #if OGRE_ARCH_TYPE == OGRE_ARCHITECTURE_64
  162|     82|        __asm__
  163|     82|        (
  164|     82|            "cpuid": "=a" (result._eax), "=b" (result._ebx), "=c" (result._ecx), "=d" (result._edx) : "a" (query)
  165|     82|        );
  166|       |        #else
  167|       |        __asm__
  168|       |        (
  169|       |            "pushl  %%ebx           \n\t"
  170|       |            "cpuid                  \n\t"
  171|       |            "movl   %%ebx, %%edi    \n\t"
  172|       |            "popl   %%ebx           \n\t"
  173|       |            : "=a" (result._eax), "=D" (result._ebx), "=c" (result._ecx), "=d" (result._edx)
  174|       |            : "a" (query)
  175|       |        );
  176|       |       #endif // OGRE_ARCHITECTURE_64
  177|     82|        return result._eax;
  178|       |
  179|       |#else
  180|       |        // TODO: Supports other compiler
  181|       |        return 0;
  182|       |#endif
  183|     82|    }
OgrePlatformInformation.cpp:_ZN4OgreL18_detectCpuFeaturesEv:
  408|      2|    {
  409|      2|        uint features = queryCpuFeatures();
  410|       |
  411|      2|        const uint sse_features = 0
  412|      2|            | PlatformInformation::CPU_FEATURE_SSE
  413|      2|            | PlatformInformation::CPU_FEATURE_SSE2
  414|      2|            | PlatformInformation::CPU_FEATURE_SSE3
  415|      2|            | PlatformInformation::CPU_FEATURE_SSE41
  416|      2|            | PlatformInformation::CPU_FEATURE_SSE42;
  417|       |
  418|      2|        if ((features & sse_features) && !_checkOperatingSystemSupportSSE())
  ------------------
  |  Branch (418:13): [True: 2, False: 0]
  |  Branch (418:42): [True: 0, False: 2]
  ------------------
  419|      0|        {
  420|      0|            features &= ~sse_features;
  421|      0|        }
  422|       |
  423|      2|        return features;
  424|      2|    }
OgrePlatformInformation.cpp:_ZN4OgreL16queryCpuFeaturesEv:
  266|      2|    {
  267|       |
  268|      2|#define CPUID_FUNC_VENDOR_ID                 0x0
  269|      2|#define CPUID_FUNC_STANDARD_FEATURES         0x1
  270|      2|#define CPUID_FUNC_EXTENSION_QUERY           0x80000000
  271|      2|#define CPUID_FUNC_EXTENDED_FEATURES         0x80000001
  272|      2|#define CPUID_FUNC_ADVANCED_POWER_MANAGEMENT 0x80000007
  273|       |
  274|      2|#define CPUID_STD_FPU               (1<<0)
  275|      2|#define CPUID_STD_TSC               (1<<4)
  276|      2|#define CPUID_STD_CMOV              (1<<15)
  277|      2|#define CPUID_STD_MMX               (1<<23)
  278|      2|#define CPUID_STD_SSE               (1<<25)
  279|      2|#define CPUID_STD_SSE2              (1<<26)
  280|      2|#define CPUID_STD_HTT               (1<<28)     // EDX[28] - Bit 28 set indicates  Hyper-Threading Technology is supported in hardware.
  281|       |
  282|      2|#define CPUID_STD_SSE3              (1<<0)      // ECX[0]  - Bit 0 of standard function 1 indicate SSE3 supported
  283|      2|#define CPUID_STD_SSE41             (1<<19)     // ECX[19] - Bit 0 of standard function 1 indicate SSE41 supported
  284|      2|#define CPUID_STD_SSE42             (1<<20)     // ECX[20] - Bit 0 of standard function 1 indicate SSE42 supported
  285|       |
  286|      2|#define CPUID_FAMILY_ID_MASK        0x0F00      // EAX[11:8] - Bit 11 thru 8 contains family  processor id
  287|      2|#define CPUID_EXT_FAMILY_ID_MASK    0x0F00000   // EAX[23:20] - Bit 23 thru 20 contains extended family processor id
  288|      2|#define CPUID_PENTIUM4_ID           0x0F00      // Pentium 4 family processor id
  289|       |
  290|      2|#define CPUID_EXT_3DNOW             (1<<31)
  291|      2|#define CPUID_EXT_AMD_3DNOWEXT      (1<<30)
  292|      2|#define CPUID_EXT_AMD_MMXEXT        (1<<22)
  293|       |
  294|       |
  295|      2|#define CPUID_APM_INVARIANT_TSC     (1<<8)      // EDX[8] - Bit 8 of function 0x80000007 indicates support for invariant TSC.
  296|       |
  297|      2|        uint features = 0;
  298|       |
  299|       |        // Supports CPUID instruction ?
  300|      2|        if (_isSupportCpuid())
  ------------------
  |  Branch (300:13): [True: 2, False: 0]
  ------------------
  301|      2|        {
  302|      2|            CpuidResult result;
  303|       |
  304|       |            // Has standard feature ?
  305|      2|            if (_performCpuid(CPUID_FUNC_VENDOR_ID, result))
  ------------------
  |  |  268|      2|#define CPUID_FUNC_VENDOR_ID                 0x0
  ------------------
  |  Branch (305:17): [True: 2, False: 0]
  ------------------
  306|      2|            {
  307|       |                // Check vendor strings
  308|      2|                if (memcmp(&result._ebx, "GenuineIntel", 12) == 0)
  ------------------
  |  Branch (308:21): [True: 0, False: 2]
  ------------------
  309|      0|                {
  310|      0|                    if (result._eax > 2)
  ------------------
  |  Branch (310:25): [True: 0, False: 0]
  ------------------
  311|      0|                        features |= PlatformInformation::CPU_FEATURE_PRO;
  312|       |
  313|       |                    // Check standard feature
  314|      0|                    _performCpuid(CPUID_FUNC_STANDARD_FEATURES, result);
  ------------------
  |  |  269|      0|#define CPUID_FUNC_STANDARD_FEATURES         0x1
  ------------------
  315|       |
  316|      0|                    if (result._edx & CPUID_STD_FPU)
  ------------------
  |  |  274|      0|#define CPUID_STD_FPU               (1<<0)
  ------------------
  |  Branch (316:25): [True: 0, False: 0]
  ------------------
  317|      0|                        features |= PlatformInformation::CPU_FEATURE_FPU;
  318|      0|                    if (result._edx & CPUID_STD_TSC)
  ------------------
  |  |  275|      0|#define CPUID_STD_TSC               (1<<4)
  ------------------
  |  Branch (318:25): [True: 0, False: 0]
  ------------------
  319|      0|                        features |= PlatformInformation::CPU_FEATURE_TSC;
  320|      0|                    if (result._edx & CPUID_STD_CMOV)
  ------------------
  |  |  276|      0|#define CPUID_STD_CMOV              (1<<15)
  ------------------
  |  Branch (320:25): [True: 0, False: 0]
  ------------------
  321|      0|                        features |= PlatformInformation::CPU_FEATURE_CMOV;
  322|      0|                    if (result._edx & CPUID_STD_MMX)
  ------------------
  |  |  277|      0|#define CPUID_STD_MMX               (1<<23)
  ------------------
  |  Branch (322:25): [True: 0, False: 0]
  ------------------
  323|      0|                        features |= PlatformInformation::CPU_FEATURE_MMX;
  324|      0|                    if (result._edx & CPUID_STD_SSE)
  ------------------
  |  |  278|      0|#define CPUID_STD_SSE               (1<<25)
  ------------------
  |  Branch (324:25): [True: 0, False: 0]
  ------------------
  325|      0|                        features |= PlatformInformation::CPU_FEATURE_MMXEXT | PlatformInformation::CPU_FEATURE_SSE;
  326|      0|                    if (result._edx & CPUID_STD_SSE2)
  ------------------
  |  |  279|      0|#define CPUID_STD_SSE2              (1<<26)
  ------------------
  |  Branch (326:25): [True: 0, False: 0]
  ------------------
  327|      0|                        features |= PlatformInformation::CPU_FEATURE_SSE2;
  328|      0|                    if (result._ecx & CPUID_STD_SSE3)
  ------------------
  |  |  282|      0|#define CPUID_STD_SSE3              (1<<0)      // ECX[0]  - Bit 0 of standard function 1 indicate SSE3 supported
  ------------------
  |  Branch (328:25): [True: 0, False: 0]
  ------------------
  329|      0|                        features |= PlatformInformation::CPU_FEATURE_SSE3;
  330|      0|                    if (result._ecx & CPUID_STD_SSE41)
  ------------------
  |  |  283|      0|#define CPUID_STD_SSE41             (1<<19)     // ECX[19] - Bit 0 of standard function 1 indicate SSE41 supported
  ------------------
  |  Branch (330:25): [True: 0, False: 0]
  ------------------
  331|      0|                        features |= PlatformInformation::CPU_FEATURE_SSE41;
  332|      0|                    if (result._ecx & CPUID_STD_SSE42)
  ------------------
  |  |  284|      0|#define CPUID_STD_SSE42             (1<<20)     // ECX[20] - Bit 0 of standard function 1 indicate SSE42 supported
  ------------------
  |  Branch (332:25): [True: 0, False: 0]
  ------------------
  333|      0|                        features |= PlatformInformation::CPU_FEATURE_SSE42;
  334|       |
  335|       |                    // Check to see if this is a Pentium 4 or later processor
  336|      0|                    if ((result._eax & CPUID_EXT_FAMILY_ID_MASK) ||
  ------------------
  |  |  287|      0|#define CPUID_EXT_FAMILY_ID_MASK    0x0F00000   // EAX[23:20] - Bit 23 thru 20 contains extended family processor id
  ------------------
  |  Branch (336:25): [True: 0, False: 0]
  ------------------
  337|      0|                        (result._eax & CPUID_FAMILY_ID_MASK) == CPUID_PENTIUM4_ID)
  ------------------
  |  |  286|      0|#define CPUID_FAMILY_ID_MASK        0x0F00      // EAX[11:8] - Bit 11 thru 8 contains family  processor id
  ------------------
                                      (result._eax & CPUID_FAMILY_ID_MASK) == CPUID_PENTIUM4_ID)
  ------------------
  |  |  288|      0|#define CPUID_PENTIUM4_ID           0x0F00      // Pentium 4 family processor id
  ------------------
  |  Branch (337:25): [True: 0, False: 0]
  ------------------
  338|      0|                    {
  339|       |                        // Check hyper-threading technology
  340|      0|                        if (result._edx & CPUID_STD_HTT)
  ------------------
  |  |  280|      0|#define CPUID_STD_HTT               (1<<28)     // EDX[28] - Bit 28 set indicates  Hyper-Threading Technology is supported in hardware.
  ------------------
  |  Branch (340:29): [True: 0, False: 0]
  ------------------
  341|      0|                            features |= PlatformInformation::CPU_FEATURE_HTT;
  342|      0|                    }
  343|       |
  344|       |
  345|      0|                    const uint maxExtensionFunctionSupport = _performCpuid(CPUID_FUNC_EXTENSION_QUERY, result);
  ------------------
  |  |  270|      0|#define CPUID_FUNC_EXTENSION_QUERY           0x80000000
  ------------------
  346|      0|                    if (maxExtensionFunctionSupport >= CPUID_FUNC_ADVANCED_POWER_MANAGEMENT)
  ------------------
  |  |  272|      0|#define CPUID_FUNC_ADVANCED_POWER_MANAGEMENT 0x80000007
  ------------------
  |  Branch (346:25): [True: 0, False: 0]
  ------------------
  347|      0|                    {
  348|      0|                        _performCpuid(CPUID_FUNC_ADVANCED_POWER_MANAGEMENT, result);
  ------------------
  |  |  272|      0|#define CPUID_FUNC_ADVANCED_POWER_MANAGEMENT 0x80000007
  ------------------
  349|       |
  350|      0|                        if (result._edx & CPUID_APM_INVARIANT_TSC)
  ------------------
  |  |  295|      0|#define CPUID_APM_INVARIANT_TSC     (1<<8)      // EDX[8] - Bit 8 of function 0x80000007 indicates support for invariant TSC.
  ------------------
  |  Branch (350:29): [True: 0, False: 0]
  ------------------
  351|      0|                            features |= PlatformInformation::CPU_FEATURE_INVARIANT_TSC;
  352|      0|                    }
  353|      0|                }
  354|      2|                else if (memcmp(&result._ebx, "AuthenticAMD", 12) == 0)
  ------------------
  |  Branch (354:26): [True: 2, False: 0]
  ------------------
  355|      2|                {
  356|      2|                    features |= PlatformInformation::CPU_FEATURE_PRO;
  357|       |
  358|       |                    // Check standard feature
  359|      2|                    _performCpuid(CPUID_FUNC_STANDARD_FEATURES, result);
  ------------------
  |  |  269|      2|#define CPUID_FUNC_STANDARD_FEATURES         0x1
  ------------------
  360|       |
  361|      2|                    if (result._edx & CPUID_STD_FPU)
  ------------------
  |  |  274|      2|#define CPUID_STD_FPU               (1<<0)
  ------------------
  |  Branch (361:25): [True: 2, False: 0]
  ------------------
  362|      2|                        features |= PlatformInformation::CPU_FEATURE_FPU;
  363|      2|                    if (result._edx & CPUID_STD_TSC)
  ------------------
  |  |  275|      2|#define CPUID_STD_TSC               (1<<4)
  ------------------
  |  Branch (363:25): [True: 2, False: 0]
  ------------------
  364|      2|                        features |= PlatformInformation::CPU_FEATURE_TSC;
  365|      2|                    if (result._edx & CPUID_STD_CMOV)
  ------------------
  |  |  276|      2|#define CPUID_STD_CMOV              (1<<15)
  ------------------
  |  Branch (365:25): [True: 2, False: 0]
  ------------------
  366|      2|                        features |= PlatformInformation::CPU_FEATURE_CMOV;
  367|      2|                    if (result._edx & CPUID_STD_MMX)
  ------------------
  |  |  277|      2|#define CPUID_STD_MMX               (1<<23)
  ------------------
  |  Branch (367:25): [True: 2, False: 0]
  ------------------
  368|      2|                        features |= PlatformInformation::CPU_FEATURE_MMX;
  369|      2|                    if (result._edx & CPUID_STD_SSE)
  ------------------
  |  |  278|      2|#define CPUID_STD_SSE               (1<<25)
  ------------------
  |  Branch (369:25): [True: 2, False: 0]
  ------------------
  370|      2|                        features |= PlatformInformation::CPU_FEATURE_SSE;
  371|      2|                    if (result._edx & CPUID_STD_SSE2)
  ------------------
  |  |  279|      2|#define CPUID_STD_SSE2              (1<<26)
  ------------------
  |  Branch (371:25): [True: 2, False: 0]
  ------------------
  372|      2|                        features |= PlatformInformation::CPU_FEATURE_SSE2;
  373|       |
  374|      2|                    if (result._ecx & CPUID_STD_SSE3)
  ------------------
  |  |  282|      2|#define CPUID_STD_SSE3              (1<<0)      // ECX[0]  - Bit 0 of standard function 1 indicate SSE3 supported
  ------------------
  |  Branch (374:25): [True: 2, False: 0]
  ------------------
  375|      2|                        features |= PlatformInformation::CPU_FEATURE_SSE3;
  376|       |
  377|       |                    // Has extended feature ?
  378|      2|                    const uint maxExtensionFunctionSupport = _performCpuid(CPUID_FUNC_EXTENSION_QUERY, result);
  ------------------
  |  |  270|      2|#define CPUID_FUNC_EXTENSION_QUERY           0x80000000
  ------------------
  379|      2|                    if (maxExtensionFunctionSupport >= CPUID_FUNC_EXTENDED_FEATURES)
  ------------------
  |  |  271|      2|#define CPUID_FUNC_EXTENDED_FEATURES         0x80000001
  ------------------
  |  Branch (379:25): [True: 2, False: 0]
  ------------------
  380|      2|                    {
  381|       |                        // Check extended feature
  382|      2|                        _performCpuid(CPUID_FUNC_EXTENDED_FEATURES, result);
  ------------------
  |  |  271|      2|#define CPUID_FUNC_EXTENDED_FEATURES         0x80000001
  ------------------
  383|       |
  384|      2|                        if (result._edx & CPUID_EXT_3DNOW)
  ------------------
  |  |  290|      2|#define CPUID_EXT_3DNOW             (1<<31)
  ------------------
  |  Branch (384:29): [True: 0, False: 2]
  ------------------
  385|      0|                            features |= PlatformInformation::CPU_FEATURE_3DNOW;
  386|      2|                        if (result._edx & CPUID_EXT_AMD_3DNOWEXT)
  ------------------
  |  |  291|      2|#define CPUID_EXT_AMD_3DNOWEXT      (1<<30)
  ------------------
  |  Branch (386:29): [True: 0, False: 2]
  ------------------
  387|      0|                            features |= PlatformInformation::CPU_FEATURE_3DNOWEXT;
  388|      2|                        if (result._edx & CPUID_EXT_AMD_MMXEXT)
  ------------------
  |  |  292|      2|#define CPUID_EXT_AMD_MMXEXT        (1<<22)
  ------------------
  |  Branch (388:29): [True: 2, False: 0]
  ------------------
  389|      2|                            features |= PlatformInformation::CPU_FEATURE_MMXEXT;
  390|      2|                    }
  391|       |
  392|       |
  393|      2|                    if (maxExtensionFunctionSupport >= CPUID_FUNC_ADVANCED_POWER_MANAGEMENT)
  ------------------
  |  |  272|      2|#define CPUID_FUNC_ADVANCED_POWER_MANAGEMENT 0x80000007
  ------------------
  |  Branch (393:25): [True: 2, False: 0]
  ------------------
  394|      2|                    {
  395|      2|                        _performCpuid(CPUID_FUNC_ADVANCED_POWER_MANAGEMENT, result);
  ------------------
  |  |  272|      2|#define CPUID_FUNC_ADVANCED_POWER_MANAGEMENT 0x80000007
  ------------------
  396|       |
  397|      2|                        if (result._edx & CPUID_APM_INVARIANT_TSC)
  ------------------
  |  |  295|      2|#define CPUID_APM_INVARIANT_TSC     (1<<8)      // EDX[8] - Bit 8 of function 0x80000007 indicates support for invariant TSC.
  ------------------
  |  Branch (397:29): [True: 2, False: 0]
  ------------------
  398|      2|                            features |= PlatformInformation::CPU_FEATURE_INVARIANT_TSC;
  399|      2|                    }
  400|      2|                }
  401|      2|            }
  402|      2|        }
  403|       |
  404|      2|        return features;
  405|      2|    }
OgrePlatformInformation.cpp:_ZN4OgreL31_checkOperatingSystemSupportSSEEv:
  202|      2|    {
  203|       |#if OGRE_COMPILER == OGRE_COMPILER_MSVC
  204|       |        /*
  205|       |            The FP part of SSE introduces a new architectural state and therefore
  206|       |            requires support from the operating system. So even if CPUID indicates
  207|       |            support for SSE FP, the application might not be able to use it. If
  208|       |            CPUID indicates support for SSE FP, check here whether it is also
  209|       |            supported by the OS, and turn off the SSE FP feature bit if there
  210|       |            is no OS support for SSE FP.
  211|       |
  212|       |            Operating systems that do not support SSE FP return an illegal
  213|       |            instruction exception if execution of an SSE FP instruction is performed.
  214|       |            Here, a sample SSE FP instruction is executed, and is checked for an
  215|       |            exception using the (non-standard) __try/__except mechanism
  216|       |            of Microsoft Visual C/C++.
  217|       |        */
  218|       |        // Visual Studio 2005, Both AMD and Intel x64 support SSE
  219|       |        // note that even though this is a build rather than runtime setting, all
  220|       |        // 64-bit CPUs support this so since binary is 64-bit only we're ok
  221|       |    #if _MSC_VER >= 1400 && defined(_M_X64)
  222|       |            return true;
  223|       |    #else
  224|       |        __try
  225|       |        {
  226|       |            __asm orps  xmm0, xmm0
  227|       |            return true;
  228|       |        }
  229|       |        __except(EXCEPTION_EXECUTE_HANDLER)
  230|       |        {
  231|       |            return false;
  232|       |        }
  233|       |    #endif
  234|       |#elif (OGRE_COMPILER == OGRE_COMPILER_GNUC || OGRE_COMPILER == OGRE_COMPILER_CLANG) && OGRE_PLATFORM != OGRE_PLATFORM_EMSCRIPTEN
  235|       |        #if OGRE_ARCH_TYPE == OGRE_ARCHITECTURE_64 
  236|      2|            return true;
  237|       |        #else
  238|       |        // Does gcc have __try/__except similar mechanism?
  239|       |        // Use signal, setjmp/longjmp instead.
  240|       |        void (*oldHandler)(int);
  241|       |        oldHandler = signal(SIGILL, _illegalHandler);
  242|       |
  243|       |        if (setjmp(sIllegalJmpBuf))
  244|       |        {
  245|       |            signal(SIGILL, oldHandler);
  246|       |            return false;
  247|       |        }
  248|       |        else
  249|       |        {
  250|       |            __asm__ __volatile__ ("orps %xmm0, %xmm0");
  251|       |            signal(SIGILL, oldHandler);
  252|       |            return true;
  253|       |        }
  254|       |       #endif
  255|       |#else
  256|       |        // TODO: Supports other compiler, assumed is supported by default
  257|       |        return true;
  258|       |#endif
  259|      2|    }
OgrePlatformInformation.cpp:_ZN4OgreL15_isSupportCpuidEv:
   83|      4|    {
   84|       |#if OGRE_COMPILER == OGRE_COMPILER_MSVC
   85|       |        // Visual Studio 2005 & 64-bit compilers always supports __cpuid intrinsic
   86|       |        // note that even though this is a build rather than runtime setting, all
   87|       |        // 64-bit CPUs support this so since binary is 64-bit only we're ok
   88|       |    #if _MSC_VER >= 1400 && defined(_M_X64)
   89|       |        return true;
   90|       |    #else
   91|       |        // If we can modify flag register bit 21, the cpu is supports CPUID instruction
   92|       |        __asm
   93|       |        {
   94|       |            // Read EFLAG
   95|       |            pushfd
   96|       |            pop     eax
   97|       |            mov     ecx, eax
   98|       |
   99|       |            // Modify bit 21
  100|       |            xor     eax, 0x200000
  101|       |            push    eax
  102|       |            popfd
  103|       |
  104|       |            // Read back EFLAG
  105|       |            pushfd
  106|       |            pop     eax
  107|       |
  108|       |            // Restore EFLAG
  109|       |            push    ecx
  110|       |            popfd
  111|       |
  112|       |            // Check bit 21 modifiable
  113|       |            xor     eax, ecx
  114|       |            neg     eax
  115|       |            sbb     eax, eax
  116|       |
  117|       |            // Return values in eax, no return statement requirement here for VC.
  118|       |        }
  119|       |    #endif
  120|       |#elif (OGRE_COMPILER == OGRE_COMPILER_GNUC || OGRE_COMPILER == OGRE_COMPILER_CLANG) && OGRE_PLATFORM != OGRE_PLATFORM_EMSCRIPTEN
  121|       |        #if OGRE_ARCH_TYPE == OGRE_ARCHITECTURE_64
  122|      4|           return true;
  123|       |       #else
  124|       |        unsigned oldFlags, newFlags;
  125|       |        __asm__
  126|       |        (
  127|       |            "pushfl         \n\t"
  128|       |            "pop    %0      \n\t"
  129|       |            "mov    %0, %1  \n\t"
  130|       |            "xor    %2, %0  \n\t"
  131|       |            "push   %0      \n\t"
  132|       |            "popfl          \n\t"
  133|       |            "pushfl         \n\t"
  134|       |            "pop    %0      \n\t"
  135|       |            "push   %1      \n\t"
  136|       |            "popfl          \n\t"
  137|       |            : "=r" (oldFlags), "=r" (newFlags)
  138|       |            : "n" (0x200000)
  139|       |        );
  140|       |        return oldFlags != newFlags;
  141|       |       #endif // 64
  142|       |#else
  143|       |        // TODO: Supports other compiler
  144|       |        return false;
  145|       |#endif
  146|      4|    }

_ZN4Ogre20ResourceGroupManagerC2Ev:
   58|      1|        : mLoadingListener(0), mCurrentGroup(0)
   59|      1|    {
   60|       |        // Create the 'General' group
   61|      1|        createResourceGroup(DEFAULT_RESOURCE_GROUP_NAME, true); // the "General" group is synonymous to global pool
   62|       |        // Create the 'Internal' group
   63|      1|        createResourceGroup(INTERNAL_RESOURCE_GROUP_NAME, true);
   64|       |        // Create the 'Autodetect' group (only used for temp storage)
   65|      1|        createResourceGroup(AUTODETECT_RESOURCE_GROUP_NAME, true); // autodetect includes the global pool
   66|       |        // default world group to the default group
   67|      1|        mWorldGroupName = DEFAULT_RESOURCE_GROUP_NAME;
   68|      1|    }
_ZN4Ogre20ResourceGroupManager19createResourceGroupERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEb:
   83|      3|    {
   84|      3|        LogManager::getSingleton().logMessage("Creating resource group " + name);
   85|      3|        if (getResourceGroup(name))
  ------------------
  |  Branch (85:13): [True: 0, False: 3]
  ------------------
   86|      0|        {
   87|      0|            OGRE_EXCEPT(Exception::ERR_DUPLICATE_ITEM, 
   88|      0|                "Resource group with name '" + name + "' already exists!", 
   89|      0|                "ResourceGroupManager::createResourceGroup");
   90|      0|        }
   91|      3|        ResourceGroup* grp = OGRE_NEW_T(ResourceGroup, MEMCATEGORY_RESOURCE)();
   92|      3|        grp->groupStatus = ResourceGroup::UNINITIALSED;
   93|      3|        grp->name = name;
   94|      3|        grp->inGlobalPool = inGlobalPool;
   95|      3|        grp->customStageCount = 0;
   96|       |
   97|      3|        OGRE_LOCK_AUTO_MUTEX;
   98|      3|        mResourceGroupMap.emplace(name, grp);
   99|      3|    }
_ZNK4Ogre20ResourceGroupManager16getResourceGroupERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEb:
 1009|      3|    {
 1010|      3|        OGRE_LOCK_AUTO_MUTEX;
 1011|      3|        ResourceGroupMap::const_iterator i = mResourceGroupMap.find(name);
 1012|       |
 1013|      3|        if (i == mResourceGroupMap.end())
  ------------------
  |  Branch (1013:13): [True: 3, False: 0]
  ------------------
 1014|      3|        {
 1015|      3|            if (throwOnFailure)
  ------------------
  |  Branch (1015:17): [True: 0, False: 3]
  ------------------
 1016|      3|                OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND, "Cannot locate a resource group called '" + name + "'");
 1017|       |
 1018|      3|            return nullptr;
 1019|      3|        }
 1020|       |
 1021|      0|        return i->second;
 1022|      3|    }

_ZN4Ogre16StreamSerialiser14makeIdentifierERA5_Kc:
  146|      2|    {
  147|      2|        uint32 ret = 0;
  148|     10|        for (size_t i = 0; i < 4; ++i)
  ------------------
  |  Branch (148:28): [True: 8, False: 2]
  ------------------
  149|      8|        {
  150|      8|            ret += (code[i] << (i * 8));
  151|      8|        }
  152|      2|        return ret;
  153|       |
  154|      2|    }

_ZN4Ogre10StringUtil4trimERNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEbb:
   42|      2|    {
   43|       |        /*
   44|       |        size_t lspaces, rspaces, len = length(), i;
   45|       |
   46|       |        lspaces = rspaces = 0;
   47|       |
   48|       |        if( left )
   49|       |        {
   50|       |            // Find spaces / tabs on the left
   51|       |            for( i = 0;
   52|       |                i < len && ( at(i) == ' ' || at(i) == '\t' || at(i) == '\r');
   53|       |                ++lspaces, ++i );
   54|       |        }
   55|       |        
   56|       |        if( right && lspaces < len )
   57|       |        {
   58|       |            // Find spaces / tabs on the right
   59|       |            for( i = len - 1;
   60|       |                i >= 0 && ( at(i) == ' ' || at(i) == '\t' || at(i) == '\r');
   61|       |                rspaces++, i-- );
   62|       |        }
   63|       |
   64|       |        *this = substr(lspaces, len-lspaces-rspaces);
   65|       |        */
   66|      2|        static const String delims = " \t\r\n";
   67|      2|        if(right)
  ------------------
  |  Branch (67:12): [True: 2, False: 0]
  ------------------
   68|      2|            str.erase(str.find_last_not_of(delims)+1); // trim right
   69|      2|        if(left)
  ------------------
  |  Branch (69:12): [True: 2, False: 0]
  ------------------
   70|      2|            str.erase(0, str.find_first_not_of(delims)); // trim left
   71|      2|    }
_ZN4Ogre10StringUtil13splitFilenameERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERS7_SA_:
  360|  4.33k|    {
  361|  4.33k|        String path = qualifiedName;
  362|       |        // Replace \ with / first
  363|  4.33k|        std::replace( path.begin(), path.end(), '\\', '/' );
  364|       |        // split based on final /
  365|  4.33k|        size_t i = path.find_last_of('/');
  366|       |
  367|  4.33k|        if (i == String::npos)
  ------------------
  |  Branch (367:13): [True: 3.38k, False: 954]
  ------------------
  368|  3.38k|        {
  369|  3.38k|            outPath.clear();
  370|  3.38k|            outBasename = qualifiedName;
  371|  3.38k|        }
  372|    954|        else
  373|    954|        {
  374|    954|            outBasename = path.substr(i+1, path.size() - i - 1);
  375|    954|            outPath = path.substr(0, i+1);
  376|    954|        }
  377|       |
  378|  4.33k|    }

_ZN4Ogre7SamplerC2Ev:
   40|      2|        : mBorderColour(ColourValue::Black)
   41|      2|        , mMaxAniso(1)
   42|      2|        , mMipmapBias(0)
   43|      2|        , mMinFilter(FO_LINEAR)
   44|      2|        , mMagFilter(FO_LINEAR)
   45|      2|        , mMipFilter(FO_POINT)
   46|      2|        , mCompareFunc(CMPF_GREATER_EQUAL)
   47|      2|        , mCompareEnabled(false)
   48|      2|        , mDirty(true)
   49|      2|    {
   50|      2|        setAddressingMode(TAM_WRAP);
   51|      2|    }
_ZN4Ogre7Sampler17setAddressingModeERKNS0_17UVWAddressingModeE:
   55|      2|    {
   56|      2|        mAddressMode = uvw;
   57|      2|        mDirty = true;
   58|      2|    }

_ZN4Ogre25EmbeddedZipArchiveFactoryC2Ev:
  343|      1|    EmbeddedZipArchiveFactory::EmbeddedZipArchiveFactory() {}
_ZN4Ogre25EmbeddedZipArchiveFactory14createInstanceERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEb:
  347|  3.75k|    {
  348|  3.75k|        auto it = gEmbeddedFileDataList->find(name);
  349|  3.75k|        if(it == gEmbeddedFileDataList->end())
  ------------------
  |  Branch (349:12): [True: 0, False: 3.75k]
  ------------------
  350|      0|            return NULL;
  351|       |
  352|       |        // TODO: decryptFunc
  353|       |
  354|  3.75k|        return new ZipArchive(name, getType(), it->second.fileData, it->second.fileSize);
  355|  3.75k|    }
_ZN4Ogre25EmbeddedZipArchiveFactory15destroyInstanceEPNS_7ArchiveE:
  357|  3.75k|    {
  358|  3.75k|        removeEmbbeddedFile(ptr->getName());
  359|  3.75k|        ZipArchiveFactory::destroyInstance(ptr);
  360|  3.75k|    }
_ZNK4Ogre25EmbeddedZipArchiveFactory7getTypeEv:
  363|  3.76k|    {
  364|  3.76k|        static String name = "EmbeddedZip";
  365|  3.76k|        return name;
  366|  3.76k|    }
_ZN4Ogre25EmbeddedZipArchiveFactory16addEmbbeddedFileERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEPKhmPFbmPvmE:
  370|  3.75k|    {
  371|  3.75k|        static bool needToInit = true;
  372|  3.75k|        if(needToInit)
  ------------------
  |  Branch (372:12): [True: 1, False: 3.75k]
  ------------------
  373|      1|        {
  374|      1|            needToInit = false;
  375|       |
  376|       |            // we can't be sure when global variables get initialized
  377|       |            // meaning it is possible our list has not been init when this
  378|       |            // function is being called. The solution is to use local
  379|       |            // static members in this function an init the pointers for the
  380|       |            // global here. We know for use that the local static variables
  381|       |            // are create in this stage.
  382|      1|            static EmbbedFileDataList sEmbbedFileDataList;
  383|      1|            gEmbeddedFileDataList = &sEmbbedFileDataList;
  384|      1|        }
  385|       |
  386|  3.75k|        EmbeddedFileData newEmbeddedFileData;
  387|  3.75k|        newEmbeddedFileData.curPos = 0;
  388|  3.75k|        newEmbeddedFileData.isFileOpened = false;
  389|  3.75k|        newEmbeddedFileData.fileData = fileData;
  390|  3.75k|        newEmbeddedFileData.fileSize = fileSize;
  391|  3.75k|        newEmbeddedFileData.decryptFunc = decryptFunc;
  392|  3.75k|        gEmbeddedFileDataList->emplace(name, newEmbeddedFileData);
  393|  3.75k|    }
_ZN4Ogre25EmbeddedZipArchiveFactory19removeEmbbeddedFileERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  396|  3.75k|    {
  397|  3.75k|        gEmbeddedFileDataList->erase(name);
  398|  3.75k|    }
OgreZip.cpp:_ZN4Ogre12_GLOBAL__N_110ZipArchiveC2ERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEESA_PKhm:
   87|  3.75k|        : Archive(name, archType), mZipFile(0)
   88|  3.75k|    {
   89|  3.75k|        if(externBuf)
  ------------------
  |  Branch (89:12): [True: 3.75k, False: 0]
  ------------------
   90|  3.75k|            mBuffer.reset(new MemoryDataStream(const_cast<uint8*>(externBuf), externBufSz));
   91|  3.75k|    }
OgreZip.cpp:_ZN4Ogre12_GLOBAL__N_110ZipArchiveD2Ev:
   94|  3.75k|    {
   95|  3.75k|        unload();
   96|  3.75k|    }
OgreZip.cpp:_ZN4Ogre12_GLOBAL__N_110ZipArchive4loadEv:
   99|  3.75k|    {
  100|  3.75k|        OGRE_LOCK_AUTO_MUTEX;
  101|  3.75k|        if (!mZipFile)
  ------------------
  |  Branch (101:13): [True: 3.75k, False: 0]
  ------------------
  102|  3.75k|        {
  103|  3.75k|            if(!mBuffer)
  ------------------
  |  Branch (103:16): [True: 0, False: 3.75k]
  ------------------
  104|      0|                mBuffer.reset(new MemoryDataStream(_openFileStream(mName, std::ios::binary)));
  105|       |
  106|  3.75k|            mZipFile = zip_stream_open((const char*)mBuffer->getPtr(), mBuffer->size(), 0, 'r');
  107|       |
  108|       |            // Cache names
  109|  3.75k|            int n = zip_entries_total(mZipFile);
  110|  7.59k|            for (int i = 0; i < n; ++i) {
  ------------------
  |  Branch (110:29): [True: 3.84k, False: 3.75k]
  ------------------
  111|  3.84k|                FileInfo info;
  112|  3.84k|                info.archive = this;
  113|       |
  114|  3.84k|                zip_entry_openbyindex(mZipFile, i);
  115|       |
  116|  3.84k|                info.filename = zip_entry_name(mZipFile);
  117|       |                // Get basename / path
  118|  3.84k|                StringUtil::splitFilename(info.filename, info.basename, info.path);
  119|       |
  120|       |                // Get sizes
  121|  3.84k|                info.uncompressedSize = zip_entry_size(mZipFile);
  122|  3.84k|                info.compressedSize = zip_entry_comp_size(mZipFile);
  123|       |
  124|  3.84k|                if (zip_entry_isdir(mZipFile))
  ------------------
  |  Branch (124:21): [True: 494, False: 3.34k]
  ------------------
  125|    494|                {
  126|    494|                    info.filename = info.filename.substr(0, info.filename.length() - 1);
  127|    494|                    StringUtil::splitFilename(info.filename, info.basename, info.path);
  128|       |                    // Set compressed size to -1 for folders; anyway nobody will check
  129|       |                    // the compressed size of a folder, and if he does, its useless anyway
  130|    494|                    info.compressedSize = size_t(-1);
  131|    494|                }
  132|       |#if !OGRE_RESOURCEMANAGER_STRICT
  133|       |                else
  134|       |                {
  135|       |                    info.filename = info.basename;
  136|       |                }
  137|       |#endif
  138|  3.84k|                zip_entry_close(mZipFile);
  139|  3.84k|                mFileList.push_back(info);
  140|  3.84k|            }
  141|  3.75k|        }
  142|  3.75k|    }
OgreZip.cpp:_ZN4Ogre12_GLOBAL__N_110ZipArchive6unloadEv:
  145|  7.51k|    {
  146|  7.51k|        OGRE_LOCK_AUTO_MUTEX;
  147|  7.51k|        if (mZipFile)
  ------------------
  |  Branch (147:13): [True: 2.43k, False: 5.08k]
  ------------------
  148|  2.43k|        {
  149|  2.43k|            zip_close(mZipFile);
  150|  2.43k|            mZipFile = 0;
  151|  2.43k|            mFileList.clear();
  152|  2.43k|            mBuffer.reset();
  153|  2.43k|        }
  154|       |    
  155|  7.51k|    }
OgreZip.cpp:_ZNK4Ogre12_GLOBAL__N_110ZipArchive4openERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEb:
  158|  3.34k|    {
  159|       |        // zip is not threadsafe
  160|  3.34k|        OGRE_LOCK_AUTO_MUTEX;
  161|  3.34k|        String lookUpFileName = filename;
  162|       |
  163|  3.34k|#if OGRE_RESOURCEMANAGER_STRICT
  164|  3.34k|        bool open = zip_entry_opencasesensitive(mZipFile, lookUpFileName.c_str()) == 0;
  165|       |#else
  166|       |        bool open = zip_entry_open(mZipFile, lookUpFileName.c_str()) == 0;
  167|       |        if (!open) // Try if we find the file
  168|       |        {
  169|       |            String basename, path;
  170|       |            StringUtil::splitFilename(lookUpFileName, basename, path);
  171|       |            const FileInfoListPtr fileNfo = findFileInfo(basename, true);
  172|       |            if (fileNfo->size() == 1) // If there are more files with the same do not open anyone
  173|       |            {
  174|       |                Ogre::FileInfo info = fileNfo->at(0);
  175|       |                lookUpFileName = info.path + info.basename;
  176|       |                open = zip_entry_open(mZipFile, lookUpFileName.c_str(), OGRE_RESOURCEMANAGER_STRICT) == 0;
  177|       |            }
  178|       |        }
  179|       |#endif
  180|       |
  181|  3.34k|        if (!open)
  ------------------
  |  Branch (181:13): [True: 893, False: 2.45k]
  ------------------
  182|    893|        {
  183|    893|            OGRE_EXCEPT(Exception::ERR_FILE_NOT_FOUND, "could not open "+lookUpFileName);
  184|    893|        }
  185|       |
  186|       |        // Construct & return stream
  187|  2.45k|        auto ret = std::make_shared<MemoryDataStream>(lookUpFileName, zip_entry_size(mZipFile), true, true);
  188|       |
  189|  2.45k|        if(zip_entry_noallocread(mZipFile, ret->getPtr(), ret->size()) < 0)
  ------------------
  |  Branch (189:12): [True: 1.81k, False: 637]
  ------------------
  190|  2.45k|            OGRE_EXCEPT(Exception::ERR_FILE_NOT_FOUND, "could not read "+lookUpFileName);
  191|    637|        zip_entry_close(mZipFile);
  192|       |
  193|    637|        return ret;
  194|  2.45k|    }
OgreZip.cpp:_ZNK4Ogre12_GLOBAL__N_110ZipArchive4listEbb:
  207|  3.75k|    {
  208|  3.75k|        OGRE_LOCK_AUTO_MUTEX;
  209|  3.75k|        auto ret = std::make_shared<StringVector>();
  210|       |
  211|  3.75k|        for (auto& f : mFileList)
  ------------------
  |  Branch (211:22): [True: 3.84k, False: 3.75k]
  ------------------
  212|  3.84k|            if ((dirs == (f.compressedSize == size_t (-1))) &&
  ------------------
  |  Branch (212:17): [True: 3.34k, False: 495]
  ------------------
  213|  3.34k|                (recursive || f.path.empty()))
  ------------------
  |  Branch (213:18): [True: 3.34k, False: 0]
  |  Branch (213:31): [True: 0, False: 0]
  ------------------
  214|  3.34k|                ret->push_back(f.filename);
  215|       |
  216|  3.75k|        return ret;
  217|  3.75k|    }

mz_crc32:
 1988|    169|mz_ulong mz_crc32(mz_ulong crc, const mz_uint8 *ptr, size_t buf_len) {
 1989|    169|  static const mz_uint32 s_crc_table[256] = {
 1990|    169|      0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, 0x076DC419, 0x706AF48F,
 1991|    169|      0xE963A535, 0x9E6495A3, 0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988,
 1992|    169|      0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91, 0x1DB71064, 0x6AB020F2,
 1993|    169|      0xF3B97148, 0x84BE41DE, 0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7,
 1994|    169|      0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC, 0x14015C4F, 0x63066CD9,
 1995|    169|      0xFA0F3D63, 0x8D080DF5, 0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172,
 1996|    169|      0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B, 0x35B5A8FA, 0x42B2986C,
 1997|    169|      0xDBBBC9D6, 0xACBCF940, 0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59,
 1998|    169|      0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116, 0x21B4F4B5, 0x56B3C423,
 1999|    169|      0xCFBA9599, 0xB8BDA50F, 0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924,
 2000|    169|      0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D, 0x76DC4190, 0x01DB7106,
 2001|    169|      0x98D220BC, 0xEFD5102A, 0x71B18589, 0x06B6B51F, 0x9FBFE4A5, 0xE8B8D433,
 2002|    169|      0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818, 0x7F6A0DBB, 0x086D3D2D,
 2003|    169|      0x91646C97, 0xE6635C01, 0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E,
 2004|    169|      0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457, 0x65B0D9C6, 0x12B7E950,
 2005|    169|      0x8BBEB8EA, 0xFCB9887C, 0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65,
 2006|    169|      0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2, 0x4ADFA541, 0x3DD895D7,
 2007|    169|      0xA4D1C46D, 0xD3D6F4FB, 0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0,
 2008|    169|      0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9, 0x5005713C, 0x270241AA,
 2009|    169|      0xBE0B1010, 0xC90C2086, 0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F,
 2010|    169|      0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4, 0x59B33D17, 0x2EB40D81,
 2011|    169|      0xB7BD5C3B, 0xC0BA6CAD, 0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A,
 2012|    169|      0xEAD54739, 0x9DD277AF, 0x04DB2615, 0x73DC1683, 0xE3630B12, 0x94643B84,
 2013|    169|      0x0D6D6A3E, 0x7A6A5AA8, 0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1,
 2014|    169|      0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE, 0xF762575D, 0x806567CB,
 2015|    169|      0x196C3671, 0x6E6B06E7, 0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC,
 2016|    169|      0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5, 0xD6D6A3E8, 0xA1D1937E,
 2017|    169|      0x38D8C2C4, 0x4FDFF252, 0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B,
 2018|    169|      0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60, 0xDF60EFC3, 0xA867DF55,
 2019|    169|      0x316E8EEF, 0x4669BE79, 0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236,
 2020|    169|      0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F, 0xC5BA3BBE, 0xB2BD0B28,
 2021|    169|      0x2BB45A92, 0x5CB36A04, 0xC2D7FFA7, 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D,
 2022|    169|      0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A, 0x9C0906A9, 0xEB0E363F,
 2023|    169|      0x72076785, 0x05005713, 0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38,
 2024|    169|      0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21, 0x86D3D2D4, 0xF1D4E242,
 2025|    169|      0x68DDB3F8, 0x1FDA836E, 0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777,
 2026|    169|      0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C, 0x8F659EFF, 0xF862AE69,
 2027|    169|      0x616BFFD3, 0x166CCF45, 0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2,
 2028|    169|      0xA7672661, 0xD06016F7, 0x4969474D, 0x3E6E77DB, 0xAED16A4A, 0xD9D65ADC,
 2029|    169|      0x40DF0B66, 0x37D83BF0, 0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9,
 2030|    169|      0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6, 0xBAD03605, 0xCDD70693,
 2031|    169|      0x54DE5729, 0x23D967BF, 0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94,
 2032|    169|      0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D};
 2033|       |
 2034|    169|  mz_uint32 crc32 = (mz_uint32)crc ^ 0xFFFFFFFF;
 2035|    169|  const mz_uint8 *pByte_buf = (const mz_uint8 *)ptr;
 2036|       |
 2037|   254k|  while (buf_len >= 4) {
  ------------------
  |  Branch (2037:10): [True: 254k, False: 169]
  ------------------
 2038|   254k|    crc32 = (crc32 >> 8) ^ s_crc_table[(crc32 ^ pByte_buf[0]) & 0xFF];
 2039|   254k|    crc32 = (crc32 >> 8) ^ s_crc_table[(crc32 ^ pByte_buf[1]) & 0xFF];
 2040|   254k|    crc32 = (crc32 >> 8) ^ s_crc_table[(crc32 ^ pByte_buf[2]) & 0xFF];
 2041|   254k|    crc32 = (crc32 >> 8) ^ s_crc_table[(crc32 ^ pByte_buf[3]) & 0xFF];
 2042|   254k|    pByte_buf += 4;
 2043|   254k|    buf_len -= 4;
 2044|   254k|  }
 2045|       |
 2046|    350|  while (buf_len) {
  ------------------
  |  Branch (2046:10): [True: 181, False: 169]
  ------------------
 2047|    181|    crc32 = (crc32 >> 8) ^ s_crc_table[(crc32 ^ pByte_buf[0]) & 0xFF];
 2048|    181|    ++pByte_buf;
 2049|    181|    --buf_len;
 2050|    181|  }
 2051|       |
 2052|    169|  return ~crc32;
 2053|    169|}
miniz_def_alloc_func:
 2059|  3.74k|                                        size_t size) {
 2060|  3.74k|  (void)opaque, (void)items, (void)size;
 2061|  3.74k|  return MZ_MALLOC(items * size);
  ------------------
  |  |  753|  3.74k|#define MZ_MALLOC(x) malloc(x)
  ------------------
 2062|  3.74k|}
miniz_def_free_func:
 2063|  14.9k|MINIZ_EXPORT void miniz_def_free_func(void *opaque, void *address) {
 2064|  14.9k|  (void)opaque, (void)address;
 2065|  14.9k|  MZ_FREE(address);
  ------------------
  |  |  754|  14.9k|#define MZ_FREE(x) free(x)
  ------------------
 2066|  14.9k|}
miniz_def_realloc_func:
 2068|  8.67k|                                          size_t items, size_t size) {
 2069|  8.67k|  (void)opaque, (void)address, (void)items, (void)size;
 2070|  8.67k|  return MZ_REALLOC(address, items * size);
  ------------------
  |  |  755|  8.67k|#define MZ_REALLOC(p, x) realloc(p, x)
  ------------------
 2071|  8.67k|}
tinfl_decompress:
 4388|  1.04k|                              const mz_uint32 decomp_flags) {
 4389|  1.04k|  static const mz_uint16 s_length_base[31] = {
 4390|  1.04k|      3,  4,  5,  6,  7,  8,  9,  10,  11,  13,  15,  17,  19,  23, 27, 31,
 4391|  1.04k|      35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0,  0};
 4392|  1.04k|  static const mz_uint8 s_length_extra[31] = {0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1,
 4393|  1.04k|                                              1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4,
 4394|  1.04k|                                              4, 4, 5, 5, 5, 5, 0, 0, 0};
 4395|  1.04k|  static const mz_uint16 s_dist_base[32] = {
 4396|  1.04k|      1,    2,    3,    4,    5,    7,     9,     13,    17,  25,   33,
 4397|  1.04k|      49,   65,   97,   129,  193,  257,   385,   513,   769, 1025, 1537,
 4398|  1.04k|      2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577, 0,   0};
 4399|  1.04k|  static const mz_uint8 s_dist_extra[32] = {
 4400|  1.04k|      0, 0, 0, 0, 1, 1, 2, 2,  3,  3,  4,  4,  5,  5,  6,
 4401|  1.04k|      6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13};
 4402|  1.04k|  static const mz_uint8 s_length_dezigzag[19] = {
 4403|  1.04k|      16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
 4404|  1.04k|  static const mz_uint16 s_min_table_sizes[3] = {257, 1, 4};
 4405|       |
 4406|  1.04k|  mz_int16 *pTrees[3];
 4407|  1.04k|  mz_uint8 *pCode_sizes[3];
 4408|       |
 4409|  1.04k|  tinfl_status status = TINFL_STATUS_FAILED;
 4410|  1.04k|  mz_uint32 num_bits, dist, counter, num_extra;
 4411|  1.04k|  tinfl_bit_buf_t bit_buf;
 4412|  1.04k|  const mz_uint8 *pIn_buf_cur = pIn_buf_next, *const pIn_buf_end =
 4413|  1.04k|                                                  pIn_buf_next + *pIn_buf_size;
 4414|  1.04k|  mz_uint8 *pOut_buf_cur = pOut_buf_next, *const pOut_buf_end =
 4415|  1.04k|                                              pOut_buf_next ? pOut_buf_next +
  ------------------
  |  Branch (4415:47): [True: 1.04k, False: 0]
  ------------------
 4416|  1.04k|                                                                  *pOut_buf_size
 4417|  1.04k|                                                            : NULL;
 4418|  1.04k|  size_t out_buf_size_mask =
 4419|  1.04k|             (decomp_flags & TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF)
  ------------------
  |  Branch (4419:14): [True: 1.04k, False: 0]
  ------------------
 4420|  1.04k|                 ? (size_t)-1
 4421|  1.04k|                 : ((pOut_buf_next - pOut_buf_start) + *pOut_buf_size) - 1,
 4422|  1.04k|         dist_from_out_buf_start;
 4423|       |
 4424|       |  /* Ensure the output buffer's size is a power of 2, unless the output buffer
 4425|       |   * is large enough to hold the entire output file (in which case it doesn't
 4426|       |   * matter). */
 4427|  1.04k|  if (((out_buf_size_mask + 1) & out_buf_size_mask) ||
  ------------------
  |  Branch (4427:7): [True: 0, False: 1.04k]
  ------------------
 4428|  1.04k|      (pOut_buf_next < pOut_buf_start)) {
  ------------------
  |  Branch (4428:7): [True: 0, False: 1.04k]
  ------------------
 4429|      0|    *pIn_buf_size = *pOut_buf_size = 0;
 4430|      0|    return TINFL_STATUS_BAD_PARAM;
 4431|      0|  }
 4432|       |
 4433|  1.04k|  pTrees[0] = r->m_tree_0;
 4434|  1.04k|  pTrees[1] = r->m_tree_1;
 4435|  1.04k|  pTrees[2] = r->m_tree_2;
 4436|  1.04k|  pCode_sizes[0] = r->m_code_size_0;
 4437|  1.04k|  pCode_sizes[1] = r->m_code_size_1;
 4438|  1.04k|  pCode_sizes[2] = r->m_code_size_2;
 4439|       |
 4440|  1.04k|  num_bits = r->m_num_bits;
 4441|  1.04k|  bit_buf = r->m_bit_buf;
 4442|  1.04k|  dist = r->m_dist;
 4443|  1.04k|  counter = r->m_counter;
 4444|  1.04k|  num_extra = r->m_num_extra;
 4445|  1.04k|  dist_from_out_buf_start = r->m_dist_from_out_buf_start;
 4446|  1.04k|  TINFL_CR_BEGIN
  ------------------
  |  | 4245|  2.09k|  switch (r->m_state) {                                                        \
  |  |  ------------------
  |  |  |  Branch (4245:11): [True: 1.04k, False: 0]
  |  |  ------------------
  |  | 4246|  1.04k|  case 0:
  |  |  ------------------
  |  |  |  Branch (4246:3): [True: 1.04k, False: 0]
  |  |  ------------------
  ------------------
 4447|       |
 4448|  1.04k|  bit_buf = num_bits = dist = counter = num_extra = r->m_zhdr0 = r->m_zhdr1 = 0;
 4449|  1.04k|  r->m_z_adler32 = r->m_check_adler32 = 1;
 4450|  1.04k|  if (decomp_flags & TINFL_FLAG_PARSE_ZLIB_HEADER) {
  ------------------
  |  Branch (4450:7): [True: 0, False: 1.04k]
  ------------------
 4451|      0|    TINFL_GET_BYTE(1, r->m_zhdr0);
  ------------------
  |  | 4265|      0|  do {                                                                         \
  |  | 4266|      0|    while (pIn_buf_cur >= pIn_buf_end) {                                       \
  |  |  ------------------
  |  |  |  Branch (4266:12): [True: 0, False: 0]
  |  |  ------------------
  |  | 4267|      0|      TINFL_CR_RETURN(state_index,                                             \
  |  |  ------------------
  |  |  |  | 4248|      0|  do {                                                                         \
  |  |  |  | 4249|      0|    status = result;                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4249:14): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 4250|      0|    r->m_state = state_index;                                                  \
  |  |  |  | 4251|      0|    goto common_exit;                                                          \
  |  |  |  | 4252|      0|  case state_index:;                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4252:3): [True: 0, False: 1.04k]
  |  |  |  |  ------------------
  |  |  |  | 4253|      0|  }                                                                            \
  |  |  |  | 4254|      0|  MZ_MACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  726|      0|#define MZ_MACRO_END while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (726:29): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 4268|      0|                      (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT)               \
  |  | 4269|      0|                          ? TINFL_STATUS_NEEDS_MORE_INPUT                      \
  |  | 4270|      0|                          : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS);         \
  |  | 4271|      0|    }                                                                          \
  |  | 4272|      0|    c = *pIn_buf_cur++;                                                        \
  |  | 4273|      0|  }                                                                            \
  |  | 4274|      0|  MZ_MACRO_END
  |  |  ------------------
  |  |  |  |  726|      0|#define MZ_MACRO_END while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (726:29): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 4452|      0|    TINFL_GET_BYTE(2, r->m_zhdr1);
  ------------------
  |  | 4265|      0|  do {                                                                         \
  |  | 4266|      0|    while (pIn_buf_cur >= pIn_buf_end) {                                       \
  |  |  ------------------
  |  |  |  Branch (4266:12): [True: 0, False: 0]
  |  |  ------------------
  |  | 4267|      0|      TINFL_CR_RETURN(state_index,                                             \
  |  |  ------------------
  |  |  |  | 4248|      0|  do {                                                                         \
  |  |  |  | 4249|      0|    status = result;                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4249:14): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 4250|      0|    r->m_state = state_index;                                                  \
  |  |  |  | 4251|      0|    goto common_exit;                                                          \
  |  |  |  | 4252|      0|  case state_index:;                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4252:3): [True: 0, False: 1.04k]
  |  |  |  |  ------------------
  |  |  |  | 4253|      0|  }                                                                            \
  |  |  |  | 4254|      0|  MZ_MACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  726|      0|#define MZ_MACRO_END while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (726:29): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 4268|      0|                      (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT)               \
  |  | 4269|      0|                          ? TINFL_STATUS_NEEDS_MORE_INPUT                      \
  |  | 4270|      0|                          : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS);         \
  |  | 4271|      0|    }                                                                          \
  |  | 4272|      0|    c = *pIn_buf_cur++;                                                        \
  |  | 4273|      0|  }                                                                            \
  |  | 4274|      0|  MZ_MACRO_END
  |  |  ------------------
  |  |  |  |  726|      0|#define MZ_MACRO_END while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (726:29): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 4453|      0|    counter = (((r->m_zhdr0 * 256 + r->m_zhdr1) % 31 != 0) ||
  ------------------
  |  Branch (4453:16): [True: 0, False: 0]
  ------------------
 4454|      0|               (r->m_zhdr1 & 32) || ((r->m_zhdr0 & 15) != 8));
  ------------------
  |  Branch (4454:16): [True: 0, False: 0]
  |  Branch (4454:37): [True: 0, False: 0]
  ------------------
 4455|      0|    if (!(decomp_flags & TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF))
  ------------------
  |  Branch (4455:9): [True: 0, False: 0]
  ------------------
 4456|      0|      counter |= (((1U << (8U + (r->m_zhdr0 >> 4))) > 32768U) ||
  ------------------
  |  Branch (4456:19): [True: 0, False: 0]
  ------------------
 4457|      0|                  ((out_buf_size_mask + 1) <
  ------------------
  |  Branch (4457:19): [True: 0, False: 0]
  ------------------
 4458|      0|                   (size_t)((size_t)1 << (8U + (r->m_zhdr0 >> 4)))));
 4459|      0|    if (counter) {
  ------------------
  |  Branch (4459:9): [True: 0, False: 0]
  ------------------
 4460|      0|      TINFL_CR_RETURN_FOREVER(36, TINFL_STATUS_FAILED);
  ------------------
  |  | 4256|      0|  do {                                                                         \
  |  | 4257|      0|    for (;;) {                                                                 \
  |  | 4258|      0|      TINFL_CR_RETURN(state_index, result);                                    \
  |  |  ------------------
  |  |  |  | 4248|      0|  do {                                                                         \
  |  |  |  | 4249|      0|    status = result;                                                           \
  |  |  |  | 4250|      0|    r->m_state = state_index;                                                  \
  |  |  |  | 4251|      0|    goto common_exit;                                                          \
  |  |  |  | 4252|      0|  case state_index:;                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4252:3): [True: 0, False: 1.04k]
  |  |  |  |  ------------------
  |  |  |  | 4253|      0|  }                                                                            \
  |  |  |  | 4254|      0|  MZ_MACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  726|      0|#define MZ_MACRO_END while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (726:29): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 4259|      0|    }                                                                          \
  |  | 4260|      0|  }                                                                            \
  |  | 4261|      0|  MZ_MACRO_END
  |  |  ------------------
  |  |  |  |  726|      0|#define MZ_MACRO_END while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (726:29): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 4461|      0|    }
 4462|      0|  }
 4463|       |
 4464|  3.82k|  do {
 4465|  3.82k|    TINFL_GET_BITS(3, r->m_final, 3);
  ------------------
  |  | 4293|  3.82k|  do {                                                                         \
  |  | 4294|  3.82k|    if (num_bits < (mz_uint)(n)) {                                             \
  |  |  ------------------
  |  |  |  Branch (4294:9): [True: 1.68k, False: 2.13k]
  |  |  ------------------
  |  | 4295|  1.68k|      TINFL_NEED_BITS(state_index, n);                                         \
  |  |  ------------------
  |  |  |  | 4277|  1.68k|  do {                                                                         \
  |  |  |  | 4278|  1.68k|    mz_uint c;                                                                 \
  |  |  |  | 4279|  1.68k|    TINFL_GET_BYTE(state_index, c);                                            \
  |  |  |  |  ------------------
  |  |  |  |  |  | 4265|  1.68k|  do {                                                                         \
  |  |  |  |  |  | 4266|  1.68k|    while (pIn_buf_cur >= pIn_buf_end) {                                       \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4266:12): [True: 37, False: 1.65k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4267|     37|      TINFL_CR_RETURN(state_index,                                             \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4248|     37|  do {                                                                         \
  |  |  |  |  |  |  |  | 4249|     74|    status = result;                                                           \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4249:14): [True: 0, False: 37]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4250|     37|    r->m_state = state_index;                                                  \
  |  |  |  |  |  |  |  | 4251|     37|    goto common_exit;                                                          \
  |  |  |  |  |  |  |  | 4252|     37|  case state_index:;                                                           \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4252:3): [True: 0, False: 1.04k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4253|      0|  }                                                                            \
  |  |  |  |  |  |  |  | 4254|     37|  MZ_MACRO_END
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  726|     37|#define MZ_MACRO_END while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (726:29): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4268|     37|                      (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT)               \
  |  |  |  |  |  | 4269|     37|                          ? TINFL_STATUS_NEEDS_MORE_INPUT                      \
  |  |  |  |  |  | 4270|     37|                          : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS);         \
  |  |  |  |  |  | 4271|     37|    }                                                                          \
  |  |  |  |  |  | 4272|  1.68k|    c = *pIn_buf_cur++;                                                        \
  |  |  |  |  |  | 4273|  1.65k|  }                                                                            \
  |  |  |  |  |  | 4274|  1.68k|  MZ_MACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  726|  1.68k|#define MZ_MACRO_END while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (726:29): [Folded, False: 1.65k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 4280|  1.68k|    bit_buf |= (((tinfl_bit_buf_t)c) << num_bits);                             \
  |  |  |  | 4281|  1.65k|    num_bits += 8;                                                             \
  |  |  |  | 4282|  1.65k|  } while (num_bits < (mz_uint)(n))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4282:12): [True: 0, False: 1.65k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 4296|  1.68k|    }                                                                          \
  |  | 4297|  3.82k|    b = bit_buf & ((1 << (n)) - 1);                                            \
  |  | 4298|  3.78k|    bit_buf >>= (n);                                                           \
  |  | 4299|  3.78k|    num_bits -= (n);                                                           \
  |  | 4300|  3.78k|  }                                                                            \
  |  | 4301|  3.82k|  MZ_MACRO_END
  |  |  ------------------
  |  |  |  |  726|  3.82k|#define MZ_MACRO_END while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (726:29): [Folded, False: 3.78k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 4466|  3.78k|    r->m_type = r->m_final >> 1;
 4467|  3.78k|    if (r->m_type == 0) {
  ------------------
  |  Branch (4467:9): [True: 925, False: 2.85k]
  ------------------
 4468|    925|      TINFL_SKIP_BITS(5, num_bits & 7);
  ------------------
  |  | 4284|    925|  do {                                                                         \
  |  | 4285|    925|    if (num_bits < (mz_uint)(n)) {                                             \
  |  |  ------------------
  |  |  |  Branch (4285:9): [True: 0, False: 925]
  |  |  ------------------
  |  | 4286|      0|      TINFL_NEED_BITS(state_index, n);                                         \
  |  |  ------------------
  |  |  |  | 4277|      0|  do {                                                                         \
  |  |  |  | 4278|      0|    mz_uint c;                                                                 \
  |  |  |  | 4279|      0|    TINFL_GET_BYTE(state_index, c);                                            \
  |  |  |  |  ------------------
  |  |  |  |  |  | 4265|      0|  do {                                                                         \
  |  |  |  |  |  | 4266|      0|    while (pIn_buf_cur >= pIn_buf_end) {                                       \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4266:12): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4267|      0|      TINFL_CR_RETURN(state_index,                                             \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4248|      0|  do {                                                                         \
  |  |  |  |  |  |  |  | 4249|      0|    status = result;                                                           \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4249:14): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4250|      0|    r->m_state = state_index;                                                  \
  |  |  |  |  |  |  |  | 4251|      0|    goto common_exit;                                                          \
  |  |  |  |  |  |  |  | 4252|      0|  case state_index:;                                                           \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4252:3): [True: 0, False: 1.04k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4253|      0|  }                                                                            \
  |  |  |  |  |  |  |  | 4254|      0|  MZ_MACRO_END
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  726|      0|#define MZ_MACRO_END while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (726:29): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4268|      0|                      (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT)               \
  |  |  |  |  |  | 4269|      0|                          ? TINFL_STATUS_NEEDS_MORE_INPUT                      \
  |  |  |  |  |  | 4270|      0|                          : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS);         \
  |  |  |  |  |  | 4271|      0|    }                                                                          \
  |  |  |  |  |  | 4272|      0|    c = *pIn_buf_cur++;                                                        \
  |  |  |  |  |  | 4273|      0|  }                                                                            \
  |  |  |  |  |  | 4274|      0|  MZ_MACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  726|      0|#define MZ_MACRO_END while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (726:29): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 4280|      0|    bit_buf |= (((tinfl_bit_buf_t)c) << num_bits);                             \
  |  |  |  | 4281|      0|    num_bits += 8;                                                             \
  |  |  |  | 4282|      0|  } while (num_bits < (mz_uint)(n))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4282:12): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 4287|      0|    }                                                                          \
  |  | 4288|    925|    bit_buf >>= (n);                                                           \
  |  | 4289|    925|    num_bits -= (n);                                                           \
  |  | 4290|    925|  }                                                                            \
  |  | 4291|    925|  MZ_MACRO_END
  |  |  ------------------
  |  |  |  |  726|    925|#define MZ_MACRO_END while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (726:29): [Folded, False: 925]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 4469|  4.60k|      for (counter = 0; counter < 4; ++counter) {
  ------------------
  |  Branch (4469:25): [True: 3.68k, False: 916]
  ------------------
 4470|  3.68k|        if (num_bits)
  ------------------
  |  Branch (4470:13): [True: 2.60k, False: 1.08k]
  ------------------
 4471|  2.60k|          TINFL_GET_BITS(6, r->m_raw_header[counter], 8);
  ------------------
  |  | 4293|  2.60k|  do {                                                                         \
  |  | 4294|  2.60k|    if (num_bits < (mz_uint)(n)) {                                             \
  |  |  ------------------
  |  |  |  Branch (4294:9): [True: 0, False: 2.60k]
  |  |  ------------------
  |  | 4295|      0|      TINFL_NEED_BITS(state_index, n);                                         \
  |  |  ------------------
  |  |  |  | 4277|      0|  do {                                                                         \
  |  |  |  | 4278|      0|    mz_uint c;                                                                 \
  |  |  |  | 4279|      0|    TINFL_GET_BYTE(state_index, c);                                            \
  |  |  |  |  ------------------
  |  |  |  |  |  | 4265|      0|  do {                                                                         \
  |  |  |  |  |  | 4266|      0|    while (pIn_buf_cur >= pIn_buf_end) {                                       \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4266:12): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4267|      0|      TINFL_CR_RETURN(state_index,                                             \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4248|      0|  do {                                                                         \
  |  |  |  |  |  |  |  | 4249|      0|    status = result;                                                           \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4249:14): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4250|      0|    r->m_state = state_index;                                                  \
  |  |  |  |  |  |  |  | 4251|      0|    goto common_exit;                                                          \
  |  |  |  |  |  |  |  | 4252|      0|  case state_index:;                                                           \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4252:3): [True: 0, False: 1.04k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4253|      0|  }                                                                            \
  |  |  |  |  |  |  |  | 4254|      0|  MZ_MACRO_END
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  726|      0|#define MZ_MACRO_END while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (726:29): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4268|      0|                      (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT)               \
  |  |  |  |  |  | 4269|      0|                          ? TINFL_STATUS_NEEDS_MORE_INPUT                      \
  |  |  |  |  |  | 4270|      0|                          : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS);         \
  |  |  |  |  |  | 4271|      0|    }                                                                          \
  |  |  |  |  |  | 4272|      0|    c = *pIn_buf_cur++;                                                        \
  |  |  |  |  |  | 4273|      0|  }                                                                            \
  |  |  |  |  |  | 4274|      0|  MZ_MACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  726|      0|#define MZ_MACRO_END while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (726:29): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 4280|      0|    bit_buf |= (((tinfl_bit_buf_t)c) << num_bits);                             \
  |  |  |  | 4281|      0|    num_bits += 8;                                                             \
  |  |  |  | 4282|      0|  } while (num_bits < (mz_uint)(n))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4282:12): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 4296|      0|    }                                                                          \
  |  | 4297|  2.60k|    b = bit_buf & ((1 << (n)) - 1);                                            \
  |  | 4298|  2.60k|    bit_buf >>= (n);                                                           \
  |  | 4299|  2.60k|    num_bits -= (n);                                                           \
  |  | 4300|  2.60k|  }                                                                            \
  |  | 4301|  2.60k|  MZ_MACRO_END
  |  |  ------------------
  |  |  |  |  726|  2.60k|#define MZ_MACRO_END while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (726:29): [Folded, False: 2.60k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 4472|  1.08k|        else
 4473|  1.08k|          TINFL_GET_BYTE(7, r->m_raw_header[counter]);
  ------------------
  |  | 4265|  1.08k|  do {                                                                         \
  |  | 4266|  1.08k|    while (pIn_buf_cur >= pIn_buf_end) {                                       \
  |  |  ------------------
  |  |  |  Branch (4266:12): [True: 9, False: 1.07k]
  |  |  ------------------
  |  | 4267|      9|      TINFL_CR_RETURN(state_index,                                             \
  |  |  ------------------
  |  |  |  | 4248|      9|  do {                                                                         \
  |  |  |  | 4249|     18|    status = result;                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4249:14): [True: 0, False: 9]
  |  |  |  |  ------------------
  |  |  |  | 4250|      9|    r->m_state = state_index;                                                  \
  |  |  |  | 4251|      9|    goto common_exit;                                                          \
  |  |  |  | 4252|      9|  case state_index:;                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4252:3): [True: 0, False: 1.04k]
  |  |  |  |  ------------------
  |  |  |  | 4253|      0|  }                                                                            \
  |  |  |  | 4254|      9|  MZ_MACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  726|      9|#define MZ_MACRO_END while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (726:29): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 4268|      9|                      (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT)               \
  |  | 4269|      9|                          ? TINFL_STATUS_NEEDS_MORE_INPUT                      \
  |  | 4270|      9|                          : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS);         \
  |  | 4271|      9|    }                                                                          \
  |  | 4272|  1.08k|    c = *pIn_buf_cur++;                                                        \
  |  | 4273|  1.07k|  }                                                                            \
  |  | 4274|  1.08k|  MZ_MACRO_END
  |  |  ------------------
  |  |  |  |  726|  1.08k|#define MZ_MACRO_END while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (726:29): [Folded, False: 1.07k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 4474|  3.68k|      }
 4475|    916|      if ((counter = (r->m_raw_header[0] | (r->m_raw_header[1] << 8))) !=
  ------------------
  |  Branch (4475:11): [True: 94, False: 822]
  ------------------
 4476|    916|          (mz_uint)(0xFFFF ^
 4477|    916|                    (r->m_raw_header[2] | (r->m_raw_header[3] << 8)))) {
 4478|     94|        TINFL_CR_RETURN_FOREVER(39, TINFL_STATUS_FAILED);
  ------------------
  |  | 4256|     94|  do {                                                                         \
  |  | 4257|     94|    for (;;) {                                                                 \
  |  | 4258|     94|      TINFL_CR_RETURN(state_index, result);                                    \
  |  |  ------------------
  |  |  |  | 4248|     94|  do {                                                                         \
  |  |  |  | 4249|     94|    status = result;                                                           \
  |  |  |  | 4250|     94|    r->m_state = state_index;                                                  \
  |  |  |  | 4251|     94|    goto common_exit;                                                          \
  |  |  |  | 4252|     94|  case state_index:;                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4252:3): [True: 0, False: 1.04k]
  |  |  |  |  ------------------
  |  |  |  | 4253|      0|  }                                                                            \
  |  |  |  | 4254|     94|  MZ_MACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  726|     94|#define MZ_MACRO_END while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (726:29): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 4259|     94|    }                                                                          \
  |  | 4260|     94|  }                                                                            \
  |  | 4261|     94|  MZ_MACRO_END
  |  |  ------------------
  |  |  |  |  726|     94|#define MZ_MACRO_END while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (726:29): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 4479|     94|      }
 4480|    890|      while ((counter) && (num_bits)) {
  ------------------
  |  Branch (4480:14): [True: 315, False: 575]
  |  Branch (4480:27): [True: 68, False: 247]
  ------------------
 4481|     68|        TINFL_GET_BITS(51, dist, 8);
  ------------------
  |  | 4293|     68|  do {                                                                         \
  |  | 4294|     68|    if (num_bits < (mz_uint)(n)) {                                             \
  |  |  ------------------
  |  |  |  Branch (4294:9): [True: 0, False: 68]
  |  |  ------------------
  |  | 4295|      0|      TINFL_NEED_BITS(state_index, n);                                         \
  |  |  ------------------
  |  |  |  | 4277|      0|  do {                                                                         \
  |  |  |  | 4278|      0|    mz_uint c;                                                                 \
  |  |  |  | 4279|      0|    TINFL_GET_BYTE(state_index, c);                                            \
  |  |  |  |  ------------------
  |  |  |  |  |  | 4265|      0|  do {                                                                         \
  |  |  |  |  |  | 4266|      0|    while (pIn_buf_cur >= pIn_buf_end) {                                       \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4266:12): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4267|      0|      TINFL_CR_RETURN(state_index,                                             \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4248|      0|  do {                                                                         \
  |  |  |  |  |  |  |  | 4249|      0|    status = result;                                                           \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4249:14): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4250|      0|    r->m_state = state_index;                                                  \
  |  |  |  |  |  |  |  | 4251|      0|    goto common_exit;                                                          \
  |  |  |  |  |  |  |  | 4252|      0|  case state_index:;                                                           \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4252:3): [True: 0, False: 1.04k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4253|      0|  }                                                                            \
  |  |  |  |  |  |  |  | 4254|      0|  MZ_MACRO_END
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  726|      0|#define MZ_MACRO_END while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (726:29): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4268|      0|                      (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT)               \
  |  |  |  |  |  | 4269|      0|                          ? TINFL_STATUS_NEEDS_MORE_INPUT                      \
  |  |  |  |  |  | 4270|      0|                          : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS);         \
  |  |  |  |  |  | 4271|      0|    }                                                                          \
  |  |  |  |  |  | 4272|      0|    c = *pIn_buf_cur++;                                                        \
  |  |  |  |  |  | 4273|      0|  }                                                                            \
  |  |  |  |  |  | 4274|      0|  MZ_MACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  726|      0|#define MZ_MACRO_END while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (726:29): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 4280|      0|    bit_buf |= (((tinfl_bit_buf_t)c) << num_bits);                             \
  |  |  |  | 4281|      0|    num_bits += 8;                                                             \
  |  |  |  | 4282|      0|  } while (num_bits < (mz_uint)(n))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4282:12): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 4296|      0|    }                                                                          \
  |  | 4297|     68|    b = bit_buf & ((1 << (n)) - 1);                                            \
  |  | 4298|     68|    bit_buf >>= (n);                                                           \
  |  | 4299|     68|    num_bits -= (n);                                                           \
  |  | 4300|     68|  }                                                                            \
  |  | 4301|     68|  MZ_MACRO_END
  |  |  ------------------
  |  |  |  |  726|     68|#define MZ_MACRO_END while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (726:29): [Folded, False: 68]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 4482|     68|        while (pOut_buf_cur >= pOut_buf_end) {
  ------------------
  |  Branch (4482:16): [True: 0, False: 68]
  ------------------
 4483|      0|          TINFL_CR_RETURN(52, TINFL_STATUS_HAS_MORE_OUTPUT);
  ------------------
  |  | 4248|      0|  do {                                                                         \
  |  | 4249|      0|    status = result;                                                           \
  |  | 4250|      0|    r->m_state = state_index;                                                  \
  |  | 4251|      0|    goto common_exit;                                                          \
  |  | 4252|      0|  case state_index:;                                                           \
  |  |  ------------------
  |  |  |  Branch (4252:3): [True: 0, False: 1.04k]
  |  |  ------------------
  |  | 4253|      0|  }                                                                            \
  |  | 4254|      0|  MZ_MACRO_END
  |  |  ------------------
  |  |  |  |  726|      0|#define MZ_MACRO_END while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (726:29): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 4484|      0|        }
 4485|     68|        *pOut_buf_cur++ = (mz_uint8)dist;
 4486|     68|        counter--;
 4487|     68|      }
 4488|  1.06k|      while (counter) {
  ------------------
  |  Branch (4488:14): [True: 330, False: 739]
  ------------------
 4489|    330|        size_t n;
 4490|    330|        while (pOut_buf_cur >= pOut_buf_end) {
  ------------------
  |  Branch (4490:16): [True: 17, False: 313]
  ------------------
 4491|     17|          TINFL_CR_RETURN(9, TINFL_STATUS_HAS_MORE_OUTPUT);
  ------------------
  |  | 4248|     17|  do {                                                                         \
  |  | 4249|     17|    status = result;                                                           \
  |  | 4250|     17|    r->m_state = state_index;                                                  \
  |  | 4251|     17|    goto common_exit;                                                          \
  |  | 4252|     17|  case state_index:;                                                           \
  |  |  ------------------
  |  |  |  Branch (4252:3): [True: 0, False: 1.04k]
  |  |  ------------------
  |  | 4253|      0|  }                                                                            \
  |  | 4254|     17|  MZ_MACRO_END
  |  |  ------------------
  |  |  |  |  726|     17|#define MZ_MACRO_END while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (726:29): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 4492|     17|        }
 4493|    313|        while (pIn_buf_cur >= pIn_buf_end) {
  ------------------
  |  Branch (4493:16): [True: 66, False: 247]
  ------------------
 4494|     66|          TINFL_CR_RETURN(38, (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT)
  ------------------
  |  | 4248|     66|  do {                                                                         \
  |  | 4249|    132|    status = result;                                                           \
  |  |  ------------------
  |  |  |  Branch (4249:14): [True: 0, False: 66]
  |  |  ------------------
  |  | 4250|     66|    r->m_state = state_index;                                                  \
  |  | 4251|     66|    goto common_exit;                                                          \
  |  | 4252|     66|  case state_index:;                                                           \
  |  |  ------------------
  |  |  |  Branch (4252:3): [True: 0, False: 1.04k]
  |  |  ------------------
  |  | 4253|      0|  }                                                                            \
  |  | 4254|     66|  MZ_MACRO_END
  |  |  ------------------
  |  |  |  |  726|     66|#define MZ_MACRO_END while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (726:29): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 4495|     66|                                  ? TINFL_STATUS_NEEDS_MORE_INPUT
 4496|     66|                                  : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS);
 4497|     66|        }
 4498|    247|        n = MZ_MIN(MZ_MIN((size_t)(pOut_buf_end - pOut_buf_cur),
  ------------------
  |  |  759|    494|#define MZ_MIN(a, b) (((a) < (b)) ? (a) : (b))
  |  |  ------------------
  |  |  |  Branch (759:23): [True: 83, False: 164]
  |  |  |  Branch (759:25): [True: 65, False: 182]
  |  |  |  Branch (759:38): [True: 16, False: 67]
  |  |  ------------------
  ------------------
 4499|    247|                          (size_t)(pIn_buf_end - pIn_buf_cur)),
 4500|    247|                   counter);
 4501|    247|        TINFL_MEMCPY(pOut_buf_cur, pIn_buf_cur, n);
  ------------------
  |  | 4241|    247|#define TINFL_MEMCPY(d, s, l) memcpy(d, s, l)
  ------------------
 4502|    247|        pIn_buf_cur += n;
 4503|    247|        pOut_buf_cur += n;
 4504|    247|        counter -= (mz_uint)n;
 4505|    247|      }
 4506|  2.85k|    } else if (r->m_type == 3) {
  ------------------
  |  Branch (4506:16): [True: 11, False: 2.84k]
  ------------------
 4507|     11|      TINFL_CR_RETURN_FOREVER(10, TINFL_STATUS_FAILED);
  ------------------
  |  | 4256|     11|  do {                                                                         \
  |  | 4257|     11|    for (;;) {                                                                 \
  |  | 4258|     11|      TINFL_CR_RETURN(state_index, result);                                    \
  |  |  ------------------
  |  |  |  | 4248|     11|  do {                                                                         \
  |  |  |  | 4249|     11|    status = result;                                                           \
  |  |  |  | 4250|     11|    r->m_state = state_index;                                                  \
  |  |  |  | 4251|     11|    goto common_exit;                                                          \
  |  |  |  | 4252|     11|  case state_index:;                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4252:3): [True: 0, False: 1.04k]
  |  |  |  |  ------------------
  |  |  |  | 4253|      0|  }                                                                            \
  |  |  |  | 4254|     11|  MZ_MACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  726|     11|#define MZ_MACRO_END while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (726:29): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 4259|     11|    }                                                                          \
  |  | 4260|     11|  }                                                                            \
  |  | 4261|     11|  MZ_MACRO_END
  |  |  ------------------
  |  |  |  |  726|     11|#define MZ_MACRO_END while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (726:29): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 4508|  2.84k|    } else {
 4509|  2.84k|      if (r->m_type == 1) {
  ------------------
  |  Branch (4509:11): [True: 2.33k, False: 515]
  ------------------
 4510|  2.33k|        mz_uint8 *p = r->m_code_size_0;
 4511|  2.33k|        mz_uint i;
 4512|  2.33k|        r->m_table_sizes[0] = 288;
 4513|  2.33k|        r->m_table_sizes[1] = 32;
 4514|  2.33k|        TINFL_MEMSET(r->m_code_size_1, 5, 32);
  ------------------
  |  | 4242|  2.33k|#define TINFL_MEMSET(p, c, l) memset(p, c, l)
  ------------------
 4515|   338k|        for (i = 0; i <= 143; ++i)
  ------------------
  |  Branch (4515:21): [True: 335k, False: 2.33k]
  ------------------
 4516|   335k|          *p++ = 8;
 4517|   263k|        for (; i <= 255; ++i)
  ------------------
  |  Branch (4517:16): [True: 261k, False: 2.33k]
  ------------------
 4518|   261k|          *p++ = 9;
 4519|  58.3k|        for (; i <= 279; ++i)
  ------------------
  |  Branch (4519:16): [True: 55.9k, False: 2.33k]
  ------------------
 4520|  55.9k|          *p++ = 7;
 4521|  20.9k|        for (; i <= 287; ++i)
  ------------------
  |  Branch (4521:16): [True: 18.6k, False: 2.33k]
  ------------------
 4522|  18.6k|          *p++ = 8;
 4523|  2.33k|      } else {
 4524|  2.05k|        for (counter = 0; counter < 3; counter++) {
  ------------------
  |  Branch (4524:27): [True: 1.54k, False: 508]
  ------------------
 4525|  1.54k|          TINFL_GET_BITS(11, r->m_table_sizes[counter], "\05\05\04"[counter]);
  ------------------
  |  | 4293|  1.54k|  do {                                                                         \
  |  | 4294|  1.54k|    if (num_bits < (mz_uint)(n)) {                                             \
  |  |  ------------------
  |  |  |  Branch (4294:9): [True: 530, False: 1.01k]
  |  |  ------------------
  |  | 4295|    530|      TINFL_NEED_BITS(state_index, n);                                         \
  |  |  ------------------
  |  |  |  | 4277|    530|  do {                                                                         \
  |  |  |  | 4278|    530|    mz_uint c;                                                                 \
  |  |  |  | 4279|    530|    TINFL_GET_BYTE(state_index, c);                                            \
  |  |  |  |  ------------------
  |  |  |  |  |  | 4265|    530|  do {                                                                         \
  |  |  |  |  |  | 4266|    530|    while (pIn_buf_cur >= pIn_buf_end) {                                       \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4266:12): [True: 7, False: 523]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4267|      7|      TINFL_CR_RETURN(state_index,                                             \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4248|      7|  do {                                                                         \
  |  |  |  |  |  |  |  | 4249|     14|    status = result;                                                           \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4249:14): [True: 0, False: 7]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4250|      7|    r->m_state = state_index;                                                  \
  |  |  |  |  |  |  |  | 4251|      7|    goto common_exit;                                                          \
  |  |  |  |  |  |  |  | 4252|      7|  case state_index:;                                                           \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4252:3): [True: 0, False: 1.04k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4253|      0|  }                                                                            \
  |  |  |  |  |  |  |  | 4254|      7|  MZ_MACRO_END
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  726|      7|#define MZ_MACRO_END while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (726:29): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4268|      7|                      (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT)               \
  |  |  |  |  |  | 4269|      7|                          ? TINFL_STATUS_NEEDS_MORE_INPUT                      \
  |  |  |  |  |  | 4270|      7|                          : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS);         \
  |  |  |  |  |  | 4271|      7|    }                                                                          \
  |  |  |  |  |  | 4272|    530|    c = *pIn_buf_cur++;                                                        \
  |  |  |  |  |  | 4273|    523|  }                                                                            \
  |  |  |  |  |  | 4274|    530|  MZ_MACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  726|    530|#define MZ_MACRO_END while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (726:29): [Folded, False: 523]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 4280|    530|    bit_buf |= (((tinfl_bit_buf_t)c) << num_bits);                             \
  |  |  |  | 4281|    523|    num_bits += 8;                                                             \
  |  |  |  | 4282|    523|  } while (num_bits < (mz_uint)(n))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4282:12): [True: 0, False: 523]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 4296|    530|    }                                                                          \
  |  | 4297|  1.54k|    b = bit_buf & ((1 << (n)) - 1);                                            \
  |  | 4298|  1.53k|    bit_buf >>= (n);                                                           \
  |  | 4299|  1.53k|    num_bits -= (n);                                                           \
  |  | 4300|  1.53k|  }                                                                            \
  |  | 4301|  1.54k|  MZ_MACRO_END
  |  |  ------------------
  |  |  |  |  726|  1.54k|#define MZ_MACRO_END while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (726:29): [Folded, False: 1.53k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 4526|  1.53k|          r->m_table_sizes[counter] += s_min_table_sizes[counter];
 4527|  1.53k|        }
 4528|    508|        MZ_CLEAR_ARR(r->m_code_size_2);
  ------------------
  |  |  761|    508|#define MZ_CLEAR_ARR(obj) memset((obj), 0, sizeof(obj))
  ------------------
 4529|  7.00k|        for (counter = 0; counter < r->m_table_sizes[2]; counter++) {
  ------------------
  |  Branch (4529:27): [True: 6.51k, False: 490]
  ------------------
 4530|  6.51k|          mz_uint s;
 4531|  6.51k|          TINFL_GET_BITS(14, s, 3);
  ------------------
  |  | 4293|  6.51k|  do {                                                                         \
  |  | 4294|  6.51k|    if (num_bits < (mz_uint)(n)) {                                             \
  |  |  ------------------
  |  |  |  Branch (4294:9): [True: 1.93k, False: 4.57k]
  |  |  ------------------
  |  | 4295|  1.93k|      TINFL_NEED_BITS(state_index, n);                                         \
  |  |  ------------------
  |  |  |  | 4277|  1.93k|  do {                                                                         \
  |  |  |  | 4278|  1.93k|    mz_uint c;                                                                 \
  |  |  |  | 4279|  1.93k|    TINFL_GET_BYTE(state_index, c);                                            \
  |  |  |  |  ------------------
  |  |  |  |  |  | 4265|  1.93k|  do {                                                                         \
  |  |  |  |  |  | 4266|  1.93k|    while (pIn_buf_cur >= pIn_buf_end) {                                       \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4266:12): [True: 18, False: 1.91k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4267|     18|      TINFL_CR_RETURN(state_index,                                             \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4248|     18|  do {                                                                         \
  |  |  |  |  |  |  |  | 4249|     36|    status = result;                                                           \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4249:14): [True: 0, False: 18]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4250|     18|    r->m_state = state_index;                                                  \
  |  |  |  |  |  |  |  | 4251|     18|    goto common_exit;                                                          \
  |  |  |  |  |  |  |  | 4252|     18|  case state_index:;                                                           \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4252:3): [True: 0, False: 1.04k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4253|      0|  }                                                                            \
  |  |  |  |  |  |  |  | 4254|     18|  MZ_MACRO_END
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  726|     18|#define MZ_MACRO_END while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (726:29): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4268|     18|                      (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT)               \
  |  |  |  |  |  | 4269|     18|                          ? TINFL_STATUS_NEEDS_MORE_INPUT                      \
  |  |  |  |  |  | 4270|     18|                          : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS);         \
  |  |  |  |  |  | 4271|     18|    }                                                                          \
  |  |  |  |  |  | 4272|  1.93k|    c = *pIn_buf_cur++;                                                        \
  |  |  |  |  |  | 4273|  1.91k|  }                                                                            \
  |  |  |  |  |  | 4274|  1.93k|  MZ_MACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  726|  1.93k|#define MZ_MACRO_END while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (726:29): [Folded, False: 1.91k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 4280|  1.93k|    bit_buf |= (((tinfl_bit_buf_t)c) << num_bits);                             \
  |  |  |  | 4281|  1.91k|    num_bits += 8;                                                             \
  |  |  |  | 4282|  1.91k|  } while (num_bits < (mz_uint)(n))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4282:12): [True: 0, False: 1.91k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 4296|  1.93k|    }                                                                          \
  |  | 4297|  6.51k|    b = bit_buf & ((1 << (n)) - 1);                                            \
  |  | 4298|  6.49k|    bit_buf >>= (n);                                                           \
  |  | 4299|  6.49k|    num_bits -= (n);                                                           \
  |  | 4300|  6.49k|  }                                                                            \
  |  | 4301|  6.51k|  MZ_MACRO_END
  |  |  ------------------
  |  |  |  |  726|  6.51k|#define MZ_MACRO_END while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (726:29): [Folded, False: 6.49k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 4532|  6.49k|          r->m_code_size_2[s_length_dezigzag[counter]] = (mz_uint8)s;
 4533|  6.49k|        }
 4534|    490|        r->m_table_sizes[2] = 19;
 4535|    490|      }
 4536|  8.49k|      for (; (int)r->m_type >= 0; r->m_type--) {
  ------------------
  |  Branch (4536:14): [True: 5.85k, False: 2.64k]
  ------------------
 4537|  5.85k|        int tree_next, tree_cur;
 4538|  5.85k|        mz_int16 *pLookUp;
 4539|  5.85k|        mz_int16 *pTree;
 4540|  5.85k|        mz_uint8 *pCode_size;
 4541|  5.85k|        mz_uint i, j, used_syms, total, sym_index, next_code[17],
 4542|  5.85k|            total_syms[16];
 4543|  5.85k|        pLookUp = r->m_look_up[r->m_type];
 4544|  5.85k|        pTree = pTrees[r->m_type];
 4545|  5.85k|        pCode_size = pCode_sizes[r->m_type];
 4546|  5.85k|        MZ_CLEAR_ARR(total_syms);
  ------------------
  |  |  761|  5.85k|#define MZ_CLEAR_ARR(obj) memset((obj), 0, sizeof(obj))
  ------------------
 4547|  5.85k|        TINFL_MEMSET(pLookUp, 0, sizeof(r->m_look_up[0]));
  ------------------
  |  | 4242|  5.85k|#define TINFL_MEMSET(p, c, l) memset(p, c, l)
  ------------------
 4548|  5.85k|        tinfl_clear_tree(r);
 4549|   865k|        for (i = 0; i < r->m_table_sizes[r->m_type]; ++i)
  ------------------
  |  Branch (4549:21): [True: 859k, False: 5.85k]
  ------------------
 4550|   859k|          total_syms[pCode_size[i]]++;
 4551|  5.85k|        used_syms = 0, total = 0;
 4552|  5.85k|        next_code[0] = next_code[1] = 0;
 4553|  93.6k|        for (i = 1; i <= 15; ++i) {
  ------------------
  |  Branch (4553:21): [True: 87.8k, False: 5.85k]
  ------------------
 4554|  87.8k|          used_syms += total_syms[i];
 4555|  87.8k|          next_code[i + 1] = (total = ((total + total_syms[i]) << 1));
 4556|  87.8k|        }
 4557|  5.85k|        if ((65536 != total) && (used_syms > 1)) {
  ------------------
  |  Branch (4557:13): [True: 725, False: 5.13k]
  |  Branch (4557:33): [True: 76, False: 649]
  ------------------
 4558|     76|          TINFL_CR_RETURN_FOREVER(35, TINFL_STATUS_FAILED);
  ------------------
  |  | 4256|     76|  do {                                                                         \
  |  | 4257|     76|    for (;;) {                                                                 \
  |  | 4258|     76|      TINFL_CR_RETURN(state_index, result);                                    \
  |  |  ------------------
  |  |  |  | 4248|     76|  do {                                                                         \
  |  |  |  | 4249|     76|    status = result;                                                           \
  |  |  |  | 4250|     76|    r->m_state = state_index;                                                  \
  |  |  |  | 4251|     76|    goto common_exit;                                                          \
  |  |  |  | 4252|     76|  case state_index:;                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4252:3): [True: 0, False: 1.04k]
  |  |  |  |  ------------------
  |  |  |  | 4253|      0|  }                                                                            \
  |  |  |  | 4254|     76|  MZ_MACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  726|     76|#define MZ_MACRO_END while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (726:29): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 4259|     76|    }                                                                          \
  |  | 4260|     76|  }                                                                            \
  |  | 4261|     76|  MZ_MACRO_END
  |  |  ------------------
  |  |  |  |  726|     76|#define MZ_MACRO_END while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (726:29): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 4559|     76|        }
 4560|  5.78k|        for (tree_next = -1, sym_index = 0;
 4561|   853k|             sym_index < r->m_table_sizes[r->m_type]; ++sym_index) {
  ------------------
  |  Branch (4561:14): [True: 848k, False: 5.78k]
  ------------------
 4562|   848k|          mz_uint rev_code = 0, l, cur_code, code_size = pCode_size[sym_index];
 4563|   848k|          if (!code_size)
  ------------------
  |  Branch (4563:15): [True: 95.7k, False: 752k]
  ------------------
 4564|  95.7k|            continue;
 4565|   752k|          cur_code = next_code[code_size]++;
 4566|  6.73M|          for (l = code_size; l > 0; l--, cur_code >>= 1)
  ------------------
  |  Branch (4566:31): [True: 5.98M, False: 752k]
  ------------------
 4567|  5.98M|            rev_code = (rev_code << 1) | (cur_code & 1);
 4568|   752k|          if (code_size <= TINFL_FAST_LOOKUP_BITS) {
  ------------------
  |  Branch (4568:15): [True: 752k, False: 205]
  ------------------
 4569|   752k|            mz_int16 k = (mz_int16)((code_size << 9) | sym_index);
 4570|  6.03M|            while (rev_code < TINFL_FAST_LOOKUP_SIZE) {
  ------------------
  |  Branch (4570:20): [True: 5.28M, False: 752k]
  ------------------
 4571|  5.28M|              pLookUp[rev_code] = k;
 4572|  5.28M|              rev_code += (1 << code_size);
 4573|  5.28M|            }
 4574|   752k|            continue;
 4575|   752k|          }
 4576|    205|          if (0 ==
  ------------------
  |  Branch (4576:15): [True: 205, False: 0]
  ------------------
 4577|    205|              (tree_cur = pLookUp[rev_code & (TINFL_FAST_LOOKUP_SIZE - 1)])) {
 4578|    205|            pLookUp[rev_code & (TINFL_FAST_LOOKUP_SIZE - 1)] =
 4579|    205|                (mz_int16)tree_next;
 4580|    205|            tree_cur = tree_next;
 4581|    205|            tree_next -= 2;
 4582|    205|          }
 4583|    205|          rev_code >>= (TINFL_FAST_LOOKUP_BITS - 1);
 4584|    755|          for (j = code_size; j > (TINFL_FAST_LOOKUP_BITS + 1); j--) {
  ------------------
  |  Branch (4584:31): [True: 550, False: 205]
  ------------------
 4585|    550|            tree_cur -= ((rev_code >>= 1) & 1);
 4586|    550|            if (!pTree[-tree_cur - 1]) {
  ------------------
  |  Branch (4586:17): [True: 550, False: 0]
  ------------------
 4587|    550|              pTree[-tree_cur - 1] = (mz_int16)tree_next;
 4588|    550|              tree_cur = tree_next;
 4589|    550|              tree_next -= 2;
 4590|    550|            } else
 4591|      0|              tree_cur = pTree[-tree_cur - 1];
 4592|    550|          }
 4593|    205|          tree_cur -= ((rev_code >>= 1) & 1);
 4594|    205|          pTree[-tree_cur - 1] = (mz_int16)sym_index;
 4595|    205|        }
 4596|  5.78k|        if (r->m_type == 2) {
  ------------------
  |  Branch (4596:13): [True: 458, False: 5.32k]
  ------------------
 4597|    458|          for (counter = 0;
 4598|  69.4k|               counter < (r->m_table_sizes[0] + r->m_table_sizes[1]);) {
  ------------------
  |  Branch (4598:16): [True: 69.0k, False: 385]
  ------------------
 4599|  69.0k|            mz_uint s;
 4600|  69.0k|            TINFL_HUFF_DECODE(16, dist, r->m_look_up[2], r->m_tree_2);
  ------------------
  |  | 4348|  69.0k|  do {                                                                         \
  |  | 4349|  69.0k|    int temp;                                                                  \
  |  | 4350|  69.0k|    mz_uint code_len, c;                                                       \
  |  | 4351|  69.0k|    if (num_bits < 15) {                                                       \
  |  |  ------------------
  |  |  |  Branch (4351:9): [True: 6.35k, False: 62.6k]
  |  |  ------------------
  |  | 4352|  6.35k|      if ((pIn_buf_end - pIn_buf_cur) < 2) {                                   \
  |  |  ------------------
  |  |  |  Branch (4352:11): [True: 450, False: 5.90k]
  |  |  ------------------
  |  | 4353|    450|        TINFL_HUFF_BITBUF_FILL(state_index, pLookUp, pTree);                   \
  |  |  ------------------
  |  |  |  | 4313|    472|  do {                                                                         \
  |  |  |  | 4314|    472|    temp = pLookUp[bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)];                    \
  |  |  |  | 4315|    472|    if (temp >= 0) {                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4315:9): [True: 472, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 4316|    472|      code_len = temp >> 9;                                                    \
  |  |  |  | 4317|    472|      if ((code_len) && (num_bits >= code_len))                                \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4317:11): [True: 451, False: 21]
  |  |  |  |  |  Branch (4317:25): [True: 398, False: 53]
  |  |  |  |  ------------------
  |  |  |  | 4318|    472|        break;                                                                 \
  |  |  |  | 4319|    472|    } else if (num_bits > TINFL_FAST_LOOKUP_BITS) {                            \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4319:16): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 4320|      0|      code_len = TINFL_FAST_LOOKUP_BITS;                                       \
  |  |  |  | 4321|      0|      do {                                                                     \
  |  |  |  | 4322|      0|        temp = pTree[~temp + ((bit_buf >> code_len++) & 1)];                   \
  |  |  |  | 4323|      0|      } while ((temp < 0) && (num_bits >= (code_len + 1)));                    \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4323:16): [True: 0, False: 0]
  |  |  |  |  |  Branch (4323:30): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 4324|      0|      if (temp >= 0)                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4324:11): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 4325|      0|        break;                                                                 \
  |  |  |  | 4326|      0|    }                                                                          \
  |  |  |  | 4327|    472|    TINFL_GET_BYTE(state_index, c);                                            \
  |  |  |  |  ------------------
  |  |  |  |  |  | 4265|     74|  do {                                                                         \
  |  |  |  |  |  | 4266|     74|    while (pIn_buf_cur >= pIn_buf_end) {                                       \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4266:12): [True: 45, False: 29]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4267|     45|      TINFL_CR_RETURN(state_index,                                             \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4248|     45|  do {                                                                         \
  |  |  |  |  |  |  |  | 4249|     90|    status = result;                                                           \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4249:14): [True: 0, False: 45]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4250|     45|    r->m_state = state_index;                                                  \
  |  |  |  |  |  |  |  | 4251|     45|    goto common_exit;                                                          \
  |  |  |  |  |  |  |  | 4252|     45|  case state_index:;                                                           \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4252:3): [True: 0, False: 1.04k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4253|      0|  }                                                                            \
  |  |  |  |  |  |  |  | 4254|     45|  MZ_MACRO_END
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  726|     45|#define MZ_MACRO_END while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (726:29): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4268|     45|                      (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT)               \
  |  |  |  |  |  | 4269|     45|                          ? TINFL_STATUS_NEEDS_MORE_INPUT                      \
  |  |  |  |  |  | 4270|     45|                          : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS);         \
  |  |  |  |  |  | 4271|     45|    }                                                                          \
  |  |  |  |  |  | 4272|     74|    c = *pIn_buf_cur++;                                                        \
  |  |  |  |  |  | 4273|     29|  }                                                                            \
  |  |  |  |  |  | 4274|    472|  MZ_MACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  726|    472|#define MZ_MACRO_END while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (726:29): [Folded, False: 29]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 4328|     74|    bit_buf |= (((tinfl_bit_buf_t)c) << num_bits);                             \
  |  |  |  | 4329|     29|    num_bits += 8;                                                             \
  |  |  |  | 4330|     29|  } while (num_bits < 15);
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4330:12): [True: 22, False: 7]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 4354|  5.90k|      } else {                                                                 \
  |  | 4355|  5.90k|        bit_buf |= (((tinfl_bit_buf_t)pIn_buf_cur[0]) << num_bits) |           \
  |  | 4356|  5.90k|                   (((tinfl_bit_buf_t)pIn_buf_cur[1]) << (num_bits + 8));      \
  |  | 4357|  5.90k|        pIn_buf_cur += 2;                                                      \
  |  | 4358|  5.90k|        num_bits += 16;                                                        \
  |  | 4359|  5.90k|      }                                                                        \
  |  | 4360|  6.35k|    }                                                                          \
  |  | 4361|  69.0k|    if ((temp = pLookUp[bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]) >= 0)         \
  |  |  ------------------
  |  |  |  Branch (4361:9): [True: 68.9k, False: 0]
  |  |  ------------------
  |  | 4362|  68.9k|      code_len = temp >> 9, temp &= 511;                                       \
  |  | 4363|  68.9k|    else {                                                                     \
  |  | 4364|      0|      code_len = TINFL_FAST_LOOKUP_BITS;                                       \
  |  | 4365|      0|      do {                                                                     \
  |  | 4366|      0|        temp = pTree[~temp + ((bit_buf >> code_len++) & 1)];                   \
  |  | 4367|      0|      } while (temp < 0);                                                      \
  |  |  ------------------
  |  |  |  Branch (4367:16): [True: 0, False: 0]
  |  |  ------------------
  |  | 4368|      0|    }                                                                          \
  |  | 4369|  68.9k|    sym = temp;                                                                \
  |  | 4370|  68.9k|    bit_buf >>= code_len;                                                      \
  |  | 4371|  68.9k|    num_bits -= code_len;                                                      \
  |  | 4372|  68.9k|  }                                                                            \
  |  | 4373|  69.0k|  MZ_MACRO_END
  |  |  ------------------
  |  |  |  |  726|  69.0k|#define MZ_MACRO_END while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (726:29): [Folded, False: 68.9k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 4601|  68.9k|            if (dist < 16) {
  ------------------
  |  Branch (4601:17): [True: 65.1k, False: 3.83k]
  ------------------
 4602|  65.1k|              r->m_len_codes[counter++] = (mz_uint8)dist;
 4603|  65.1k|              continue;
 4604|  65.1k|            }
 4605|  3.83k|            if ((dist == 16) && (!counter)) {
  ------------------
  |  Branch (4605:17): [True: 1.14k, False: 2.68k]
  |  Branch (4605:33): [True: 12, False: 1.13k]
  ------------------
 4606|     12|              TINFL_CR_RETURN_FOREVER(17, TINFL_STATUS_FAILED);
  ------------------
  |  | 4256|     12|  do {                                                                         \
  |  | 4257|     12|    for (;;) {                                                                 \
  |  | 4258|     12|      TINFL_CR_RETURN(state_index, result);                                    \
  |  |  ------------------
  |  |  |  | 4248|     12|  do {                                                                         \
  |  |  |  | 4249|     12|    status = result;                                                           \
  |  |  |  | 4250|     12|    r->m_state = state_index;                                                  \
  |  |  |  | 4251|     12|    goto common_exit;                                                          \
  |  |  |  | 4252|     12|  case state_index:;                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4252:3): [True: 0, False: 1.04k]
  |  |  |  |  ------------------
  |  |  |  | 4253|      0|  }                                                                            \
  |  |  |  | 4254|     12|  MZ_MACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  726|     12|#define MZ_MACRO_END while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (726:29): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 4259|     12|    }                                                                          \
  |  | 4260|     12|  }                                                                            \
  |  | 4261|     12|  MZ_MACRO_END
  |  |  ------------------
  |  |  |  |  726|     12|#define MZ_MACRO_END while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (726:29): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 4607|     12|            }
 4608|  3.81k|            num_extra = "\02\03\07"[dist - 16];
 4609|  3.81k|            TINFL_GET_BITS(18, s, num_extra);
  ------------------
  |  | 4293|  3.81k|  do {                                                                         \
  |  | 4294|  3.81k|    if (num_bits < (mz_uint)(n)) {                                             \
  |  |  ------------------
  |  |  |  Branch (4294:9): [True: 25, False: 3.79k]
  |  |  ------------------
  |  | 4295|     25|      TINFL_NEED_BITS(state_index, n);                                         \
  |  |  ------------------
  |  |  |  | 4277|     25|  do {                                                                         \
  |  |  |  | 4278|     25|    mz_uint c;                                                                 \
  |  |  |  | 4279|     25|    TINFL_GET_BYTE(state_index, c);                                            \
  |  |  |  |  ------------------
  |  |  |  |  |  | 4265|     25|  do {                                                                         \
  |  |  |  |  |  | 4266|     25|    while (pIn_buf_cur >= pIn_buf_end) {                                       \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4266:12): [True: 16, False: 9]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4267|     16|      TINFL_CR_RETURN(state_index,                                             \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4248|     16|  do {                                                                         \
  |  |  |  |  |  |  |  | 4249|     32|    status = result;                                                           \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4249:14): [True: 0, False: 16]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4250|     16|    r->m_state = state_index;                                                  \
  |  |  |  |  |  |  |  | 4251|     16|    goto common_exit;                                                          \
  |  |  |  |  |  |  |  | 4252|     16|  case state_index:;                                                           \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4252:3): [True: 0, False: 1.04k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4253|      0|  }                                                                            \
  |  |  |  |  |  |  |  | 4254|     16|  MZ_MACRO_END
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  726|     16|#define MZ_MACRO_END while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (726:29): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4268|     16|                      (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT)               \
  |  |  |  |  |  | 4269|     16|                          ? TINFL_STATUS_NEEDS_MORE_INPUT                      \
  |  |  |  |  |  | 4270|     16|                          : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS);         \
  |  |  |  |  |  | 4271|     16|    }                                                                          \
  |  |  |  |  |  | 4272|     25|    c = *pIn_buf_cur++;                                                        \
  |  |  |  |  |  | 4273|      9|  }                                                                            \
  |  |  |  |  |  | 4274|     25|  MZ_MACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  726|     25|#define MZ_MACRO_END while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (726:29): [Folded, False: 9]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 4280|     25|    bit_buf |= (((tinfl_bit_buf_t)c) << num_bits);                             \
  |  |  |  | 4281|      9|    num_bits += 8;                                                             \
  |  |  |  | 4282|      9|  } while (num_bits < (mz_uint)(n))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4282:12): [True: 0, False: 9]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 4296|     25|    }                                                                          \
  |  | 4297|  3.81k|    b = bit_buf & ((1 << (n)) - 1);                                            \
  |  | 4298|  3.80k|    bit_buf >>= (n);                                                           \
  |  | 4299|  3.80k|    num_bits -= (n);                                                           \
  |  | 4300|  3.80k|  }                                                                            \
  |  | 4301|  3.81k|  MZ_MACRO_END
  |  |  ------------------
  |  |  |  |  726|  3.81k|#define MZ_MACRO_END while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (726:29): [Folded, False: 3.80k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 4610|  3.80k|            s += "\03\03\013"[dist - 16];
 4611|  3.80k|            TINFL_MEMSET(r->m_len_codes + counter,
  ------------------
  |  | 4242|  7.60k|#define TINFL_MEMSET(p, c, l) memset(p, c, l)
  |  |  ------------------
  |  |  |  Branch (4242:41): [True: 1.13k, False: 2.67k]
  |  |  ------------------
  ------------------
 4612|  3.80k|                         (dist == 16) ? r->m_len_codes[counter - 1] : 0, s);
 4613|  3.80k|            counter += s;
 4614|  3.80k|          }
 4615|    385|          if ((r->m_table_sizes[0] + r->m_table_sizes[1]) != counter) {
  ------------------
  |  Branch (4615:15): [True: 32, False: 353]
  ------------------
 4616|     32|            TINFL_CR_RETURN_FOREVER(21, TINFL_STATUS_FAILED);
  ------------------
  |  | 4256|     32|  do {                                                                         \
  |  | 4257|     32|    for (;;) {                                                                 \
  |  | 4258|     32|      TINFL_CR_RETURN(state_index, result);                                    \
  |  |  ------------------
  |  |  |  | 4248|     32|  do {                                                                         \
  |  |  |  | 4249|     32|    status = result;                                                           \
  |  |  |  | 4250|     32|    r->m_state = state_index;                                                  \
  |  |  |  | 4251|     32|    goto common_exit;                                                          \
  |  |  |  | 4252|     32|  case state_index:;                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4252:3): [True: 0, False: 1.04k]
  |  |  |  |  ------------------
  |  |  |  | 4253|      0|  }                                                                            \
  |  |  |  | 4254|     32|  MZ_MACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  726|     32|#define MZ_MACRO_END while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (726:29): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 4259|     32|    }                                                                          \
  |  | 4260|     32|  }                                                                            \
  |  | 4261|     32|  MZ_MACRO_END
  |  |  ------------------
  |  |  |  |  726|     32|#define MZ_MACRO_END while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (726:29): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 4617|     32|          }
 4618|    353|          TINFL_MEMCPY(r->m_code_size_0, r->m_len_codes, r->m_table_sizes[0]);
  ------------------
  |  | 4241|    353|#define TINFL_MEMCPY(d, s, l) memcpy(d, s, l)
  ------------------
 4619|    353|          TINFL_MEMCPY(r->m_code_size_1, r->m_len_codes + r->m_table_sizes[0],
  ------------------
  |  | 4241|    353|#define TINFL_MEMCPY(d, s, l) memcpy(d, s, l)
  ------------------
 4620|    353|                       r->m_table_sizes[1]);
 4621|    353|        }
 4622|  5.78k|      }
 4623|   182k|      for (;;) {
 4624|   182k|        mz_uint8 *pSrc;
 4625|   842M|        for (;;) {
 4626|   842M|          if (((pIn_buf_end - pIn_buf_cur) < 4) ||
  ------------------
  |  Branch (4626:15): [True: 359M, False: 482M]
  ------------------
 4627|   482M|              ((pOut_buf_end - pOut_buf_cur) < 2)) {
  ------------------
  |  Branch (4627:15): [True: 680, False: 482M]
  ------------------
 4628|   359M|            TINFL_HUFF_DECODE(23, counter, r->m_look_up[0], r->m_tree_0);
  ------------------
  |  | 4348|   359M|  do {                                                                         \
  |  | 4349|   359M|    int temp;                                                                  \
  |  | 4350|   359M|    mz_uint code_len, c;                                                       \
  |  | 4351|   359M|    if (num_bits < 15) {                                                       \
  |  |  ------------------
  |  |  |  Branch (4351:9): [True: 826, False: 359M]
  |  |  ------------------
  |  | 4352|    826|      if ((pIn_buf_end - pIn_buf_cur) < 2) {                                   \
  |  |  ------------------
  |  |  |  Branch (4352:11): [True: 567, False: 259]
  |  |  ------------------
  |  | 4353|    567|        TINFL_HUFF_BITBUF_FILL(state_index, pLookUp, pTree);                   \
  |  |  ------------------
  |  |  |  | 4313|    657|  do {                                                                         \
  |  |  |  | 4314|    657|    temp = pLookUp[bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)];                    \
  |  |  |  | 4315|    657|    if (temp >= 0) {                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4315:9): [True: 578, False: 79]
  |  |  |  |  ------------------
  |  |  |  | 4316|    578|      code_len = temp >> 9;                                                    \
  |  |  |  | 4317|    578|      if ((code_len) && (num_bits >= code_len))                                \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4317:11): [True: 561, False: 17]
  |  |  |  |  |  Branch (4317:25): [True: 423, False: 138]
  |  |  |  |  ------------------
  |  |  |  | 4318|    578|        break;                                                                 \
  |  |  |  | 4319|    578|    } else if (num_bits > TINFL_FAST_LOOKUP_BITS) {                            \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4319:16): [True: 35, False: 44]
  |  |  |  |  ------------------
  |  |  |  | 4320|     35|      code_len = TINFL_FAST_LOOKUP_BITS;                                       \
  |  |  |  | 4321|     85|      do {                                                                     \
  |  |  |  | 4322|     85|        temp = pTree[~temp + ((bit_buf >> code_len++) & 1)];                   \
  |  |  |  | 4323|     85|      } while ((temp < 0) && (num_bits >= (code_len + 1)));                    \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4323:16): [True: 65, False: 20]
  |  |  |  |  |  Branch (4323:30): [True: 50, False: 15]
  |  |  |  |  ------------------
  |  |  |  | 4324|     35|      if (temp >= 0)                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4324:11): [True: 20, False: 15]
  |  |  |  |  ------------------
  |  |  |  | 4325|     35|        break;                                                                 \
  |  |  |  | 4326|     35|    }                                                                          \
  |  |  |  | 4327|    657|    TINFL_GET_BYTE(state_index, c);                                            \
  |  |  |  |  ------------------
  |  |  |  |  |  | 4265|    214|  do {                                                                         \
  |  |  |  |  |  | 4266|    214|    while (pIn_buf_cur >= pIn_buf_end) {                                       \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4266:12): [True: 100, False: 114]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4267|    100|      TINFL_CR_RETURN(state_index,                                             \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4248|    100|  do {                                                                         \
  |  |  |  |  |  |  |  | 4249|    200|    status = result;                                                           \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4249:14): [True: 0, False: 100]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4250|    100|    r->m_state = state_index;                                                  \
  |  |  |  |  |  |  |  | 4251|    100|    goto common_exit;                                                          \
  |  |  |  |  |  |  |  | 4252|    100|  case state_index:;                                                           \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4252:3): [True: 0, False: 1.04k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4253|      0|  }                                                                            \
  |  |  |  |  |  |  |  | 4254|    100|  MZ_MACRO_END
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  726|    100|#define MZ_MACRO_END while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (726:29): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4268|    100|                      (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT)               \
  |  |  |  |  |  | 4269|    100|                          ? TINFL_STATUS_NEEDS_MORE_INPUT                      \
  |  |  |  |  |  | 4270|    100|                          : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS);         \
  |  |  |  |  |  | 4271|    100|    }                                                                          \
  |  |  |  |  |  | 4272|    214|    c = *pIn_buf_cur++;                                                        \
  |  |  |  |  |  | 4273|    114|  }                                                                            \
  |  |  |  |  |  | 4274|    657|  MZ_MACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  726|    657|#define MZ_MACRO_END while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (726:29): [Folded, False: 114]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 4328|    214|    bit_buf |= (((tinfl_bit_buf_t)c) << num_bits);                             \
  |  |  |  | 4329|    114|    num_bits += 8;                                                             \
  |  |  |  | 4330|    114|  } while (num_bits < 15);
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4330:12): [True: 90, False: 24]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 4354|    467|      } else {                                                                 \
  |  | 4355|    259|        bit_buf |= (((tinfl_bit_buf_t)pIn_buf_cur[0]) << num_bits) |           \
  |  | 4356|    259|                   (((tinfl_bit_buf_t)pIn_buf_cur[1]) << (num_bits + 8));      \
  |  | 4357|    259|        pIn_buf_cur += 2;                                                      \
  |  | 4358|    259|        num_bits += 16;                                                        \
  |  | 4359|    259|      }                                                                        \
  |  | 4360|    826|    }                                                                          \
  |  | 4361|   359M|    if ((temp = pLookUp[bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]) >= 0)         \
  |  |  ------------------
  |  |  |  Branch (4361:9): [True: 359M, False: 121]
  |  |  ------------------
  |  | 4362|   359M|      code_len = temp >> 9, temp &= 511;                                       \
  |  | 4363|   359M|    else {                                                                     \
  |  | 4364|    121|      code_len = TINFL_FAST_LOOKUP_BITS;                                       \
  |  | 4365|    313|      do {                                                                     \
  |  | 4366|    313|        temp = pTree[~temp + ((bit_buf >> code_len++) & 1)];                   \
  |  | 4367|    313|      } while (temp < 0);                                                      \
  |  |  ------------------
  |  |  |  Branch (4367:16): [True: 192, False: 121]
  |  |  ------------------
  |  | 4368|    121|    }                                                                          \
  |  | 4369|   359M|    sym = temp;                                                                \
  |  | 4370|   359M|    bit_buf >>= code_len;                                                      \
  |  | 4371|   359M|    num_bits -= code_len;                                                      \
  |  | 4372|   359M|  }                                                                            \
  |  | 4373|   359M|  MZ_MACRO_END
  |  |  ------------------
  |  |  |  |  726|   359M|#define MZ_MACRO_END while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (726:29): [Folded, False: 359M]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 4629|   359M|            if (counter >= 256)
  ------------------
  |  Branch (4629:17): [True: 1.40k, False: 359M]
  ------------------
 4630|  1.40k|              break;
 4631|   359M|            while (pOut_buf_cur >= pOut_buf_end) {
  ------------------
  |  Branch (4631:20): [True: 145, False: 359M]
  ------------------
 4632|    145|              TINFL_CR_RETURN(24, TINFL_STATUS_HAS_MORE_OUTPUT);
  ------------------
  |  | 4248|    145|  do {                                                                         \
  |  | 4249|    145|    status = result;                                                           \
  |  | 4250|    145|    r->m_state = state_index;                                                  \
  |  | 4251|    145|    goto common_exit;                                                          \
  |  | 4252|    145|  case state_index:;                                                           \
  |  |  ------------------
  |  |  |  Branch (4252:3): [True: 0, False: 1.04k]
  |  |  ------------------
  |  | 4253|      0|  }                                                                            \
  |  | 4254|    145|  MZ_MACRO_END
  |  |  ------------------
  |  |  |  |  726|    145|#define MZ_MACRO_END while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (726:29): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 4633|    145|            }
 4634|   359M|            *pOut_buf_cur++ = (mz_uint8)counter;
 4635|   482M|          } else {
 4636|   482M|            int sym2;
 4637|   482M|            mz_uint code_len;
 4638|   482M|#if TINFL_USE_64BIT_BITBUF
 4639|   482M|            if (num_bits < 30) {
  ------------------
  |  Branch (4639:17): [True: 50.0k, False: 482M]
  ------------------
 4640|  50.0k|              bit_buf |=
 4641|  50.0k|                  (((tinfl_bit_buf_t)MZ_READ_LE32(pIn_buf_cur)) << num_bits);
  ------------------
  |  |  772|  50.0k|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  773|  50.0k|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) |                           \
  |  |  774|  50.0k|   ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) |                          \
  |  |  775|  50.0k|   ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U))
  ------------------
 4642|  50.0k|              pIn_buf_cur += 4;
 4643|  50.0k|              num_bits += 32;
 4644|  50.0k|            }
 4645|       |#else
 4646|       |            if (num_bits < 15) {
 4647|       |              bit_buf |=
 4648|       |                  (((tinfl_bit_buf_t)MZ_READ_LE16(pIn_buf_cur)) << num_bits);
 4649|       |              pIn_buf_cur += 2;
 4650|       |              num_bits += 16;
 4651|       |            }
 4652|       |#endif
 4653|   482M|            if ((sym2 =
  ------------------
  |  Branch (4653:17): [True: 482M, False: 1.47k]
  ------------------
 4654|   482M|                     r->m_look_up[0][bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]) >=
 4655|   482M|                0)
 4656|   482M|              code_len = sym2 >> 9;
 4657|  1.47k|            else {
 4658|  1.47k|              code_len = TINFL_FAST_LOOKUP_BITS;
 4659|  5.15k|              do {
 4660|  5.15k|                sym2 = r->m_tree_0[~sym2 + ((bit_buf >> code_len++) & 1)];
 4661|  5.15k|              } while (sym2 < 0);
  ------------------
  |  Branch (4661:24): [True: 3.68k, False: 1.47k]
  ------------------
 4662|  1.47k|            }
 4663|   482M|            counter = sym2;
 4664|   482M|            bit_buf >>= code_len;
 4665|   482M|            num_bits -= code_len;
 4666|   482M|            if (counter & 256)
  ------------------
  |  Branch (4666:17): [True: 141k, False: 482M]
  ------------------
 4667|   141k|              break;
 4668|       |
 4669|       |#if !TINFL_USE_64BIT_BITBUF
 4670|       |            if (num_bits < 15) {
 4671|       |              bit_buf |=
 4672|       |                  (((tinfl_bit_buf_t)MZ_READ_LE16(pIn_buf_cur)) << num_bits);
 4673|       |              pIn_buf_cur += 2;
 4674|       |              num_bits += 16;
 4675|       |            }
 4676|       |#endif
 4677|   482M|            if ((sym2 =
  ------------------
  |  Branch (4677:17): [True: 482M, False: 401]
  ------------------
 4678|   482M|                     r->m_look_up[0][bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]) >=
 4679|   482M|                0)
 4680|   482M|              code_len = sym2 >> 9;
 4681|    401|            else {
 4682|    401|              code_len = TINFL_FAST_LOOKUP_BITS;
 4683|    727|              do {
 4684|    727|                sym2 = r->m_tree_0[~sym2 + ((bit_buf >> code_len++) & 1)];
 4685|    727|              } while (sym2 < 0);
  ------------------
  |  Branch (4685:24): [True: 326, False: 401]
  ------------------
 4686|    401|            }
 4687|   482M|            bit_buf >>= code_len;
 4688|   482M|            num_bits -= code_len;
 4689|       |
 4690|   482M|            pOut_buf_cur[0] = (mz_uint8)counter;
 4691|   482M|            if (sym2 & 256) {
  ------------------
  |  Branch (4691:17): [True: 38.8k, False: 482M]
  ------------------
 4692|  38.8k|              pOut_buf_cur++;
 4693|  38.8k|              counter = sym2;
 4694|  38.8k|              break;
 4695|  38.8k|            }
 4696|   482M|            pOut_buf_cur[1] = (mz_uint8)sym2;
 4697|   482M|            pOut_buf_cur += 2;
 4698|   482M|          }
 4699|   842M|        }
 4700|   182k|        if ((counter &= 511) == 256)
  ------------------
  |  Branch (4700:13): [True: 2.16k, False: 179k]
  ------------------
 4701|  2.16k|          break;
 4702|       |
 4703|   179k|        num_extra = s_length_extra[counter - 257];
 4704|   179k|        counter = s_length_base[counter - 257];
 4705|   179k|        if (num_extra) {
  ------------------
  |  Branch (4705:13): [True: 31.7k, False: 148k]
  ------------------
 4706|  31.7k|          mz_uint extra_bits;
 4707|  31.7k|          TINFL_GET_BITS(25, extra_bits, num_extra);
  ------------------
  |  | 4293|  31.7k|  do {                                                                         \
  |  | 4294|  31.7k|    if (num_bits < (mz_uint)(n)) {                                             \
  |  |  ------------------
  |  |  |  Branch (4294:9): [True: 25, False: 31.7k]
  |  |  ------------------
  |  | 4295|     25|      TINFL_NEED_BITS(state_index, n);                                         \
  |  |  ------------------
  |  |  |  | 4277|     25|  do {                                                                         \
  |  |  |  | 4278|     25|    mz_uint c;                                                                 \
  |  |  |  | 4279|     25|    TINFL_GET_BYTE(state_index, c);                                            \
  |  |  |  |  ------------------
  |  |  |  |  |  | 4265|     25|  do {                                                                         \
  |  |  |  |  |  | 4266|     25|    while (pIn_buf_cur >= pIn_buf_end) {                                       \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4266:12): [True: 11, False: 14]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4267|     11|      TINFL_CR_RETURN(state_index,                                             \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4248|     11|  do {                                                                         \
  |  |  |  |  |  |  |  | 4249|     22|    status = result;                                                           \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4249:14): [True: 0, False: 11]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4250|     11|    r->m_state = state_index;                                                  \
  |  |  |  |  |  |  |  | 4251|     11|    goto common_exit;                                                          \
  |  |  |  |  |  |  |  | 4252|     11|  case state_index:;                                                           \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4252:3): [True: 0, False: 1.04k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4253|      0|  }                                                                            \
  |  |  |  |  |  |  |  | 4254|     11|  MZ_MACRO_END
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  726|     11|#define MZ_MACRO_END while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (726:29): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4268|     11|                      (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT)               \
  |  |  |  |  |  | 4269|     11|                          ? TINFL_STATUS_NEEDS_MORE_INPUT                      \
  |  |  |  |  |  | 4270|     11|                          : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS);         \
  |  |  |  |  |  | 4271|     11|    }                                                                          \
  |  |  |  |  |  | 4272|     25|    c = *pIn_buf_cur++;                                                        \
  |  |  |  |  |  | 4273|     14|  }                                                                            \
  |  |  |  |  |  | 4274|     25|  MZ_MACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  726|     25|#define MZ_MACRO_END while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (726:29): [Folded, False: 14]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 4280|     25|    bit_buf |= (((tinfl_bit_buf_t)c) << num_bits);                             \
  |  |  |  | 4281|     14|    num_bits += 8;                                                             \
  |  |  |  | 4282|     14|  } while (num_bits < (mz_uint)(n))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4282:12): [True: 0, False: 14]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 4296|     25|    }                                                                          \
  |  | 4297|  31.7k|    b = bit_buf & ((1 << (n)) - 1);                                            \
  |  | 4298|  31.7k|    bit_buf >>= (n);                                                           \
  |  | 4299|  31.7k|    num_bits -= (n);                                                           \
  |  | 4300|  31.7k|  }                                                                            \
  |  | 4301|  31.7k|  MZ_MACRO_END
  |  |  ------------------
  |  |  |  |  726|  31.7k|#define MZ_MACRO_END while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (726:29): [Folded, False: 31.7k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 4708|  31.7k|          counter += extra_bits;
 4709|  31.7k|        }
 4710|       |
 4711|   179k|        TINFL_HUFF_DECODE(26, dist, r->m_look_up[1], r->m_tree_1);
  ------------------
  |  | 4348|   179k|  do {                                                                         \
  |  | 4349|   179k|    int temp;                                                                  \
  |  | 4350|   179k|    mz_uint code_len, c;                                                       \
  |  | 4351|   179k|    if (num_bits < 15) {                                                       \
  |  |  ------------------
  |  |  |  Branch (4351:9): [True: 833, False: 179k]
  |  |  ------------------
  |  | 4352|    833|      if ((pIn_buf_end - pIn_buf_cur) < 2) {                                   \
  |  |  ------------------
  |  |  |  Branch (4352:11): [True: 269, False: 564]
  |  |  ------------------
  |  | 4353|    269|        TINFL_HUFF_BITBUF_FILL(state_index, pLookUp, pTree);                   \
  |  |  ------------------
  |  |  |  | 4313|    299|  do {                                                                         \
  |  |  |  | 4314|    299|    temp = pLookUp[bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)];                    \
  |  |  |  | 4315|    299|    if (temp >= 0) {                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4315:9): [True: 250, False: 49]
  |  |  |  |  ------------------
  |  |  |  | 4316|    250|      code_len = temp >> 9;                                                    \
  |  |  |  | 4317|    250|      if ((code_len) && (num_bits >= code_len))                                \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4317:11): [True: 193, False: 57]
  |  |  |  |  |  Branch (4317:25): [True: 160, False: 33]
  |  |  |  |  ------------------
  |  |  |  | 4318|    250|        break;                                                                 \
  |  |  |  | 4319|    250|    } else if (num_bits > TINFL_FAST_LOOKUP_BITS) {                            \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4319:16): [True: 18, False: 31]
  |  |  |  |  ------------------
  |  |  |  | 4320|     18|      code_len = TINFL_FAST_LOOKUP_BITS;                                       \
  |  |  |  | 4321|     48|      do {                                                                     \
  |  |  |  | 4322|     48|        temp = pTree[~temp + ((bit_buf >> code_len++) & 1)];                   \
  |  |  |  | 4323|     48|      } while ((temp < 0) && (num_bits >= (code_len + 1)));                    \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4323:16): [True: 36, False: 12]
  |  |  |  |  |  Branch (4323:30): [True: 30, False: 6]
  |  |  |  |  ------------------
  |  |  |  | 4324|     18|      if (temp >= 0)                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4324:11): [True: 12, False: 6]
  |  |  |  |  ------------------
  |  |  |  | 4325|     18|        break;                                                                 \
  |  |  |  | 4326|     18|    }                                                                          \
  |  |  |  | 4327|    299|    TINFL_GET_BYTE(state_index, c);                                            \
  |  |  |  |  ------------------
  |  |  |  |  |  | 4265|    127|  do {                                                                         \
  |  |  |  |  |  | 4266|    127|    while (pIn_buf_cur >= pIn_buf_end) {                                       \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4266:12): [True: 66, False: 61]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4267|     66|      TINFL_CR_RETURN(state_index,                                             \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4248|     66|  do {                                                                         \
  |  |  |  |  |  |  |  | 4249|    132|    status = result;                                                           \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4249:14): [True: 0, False: 66]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4250|     66|    r->m_state = state_index;                                                  \
  |  |  |  |  |  |  |  | 4251|     66|    goto common_exit;                                                          \
  |  |  |  |  |  |  |  | 4252|     66|  case state_index:;                                                           \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4252:3): [True: 0, False: 1.04k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4253|      0|  }                                                                            \
  |  |  |  |  |  |  |  | 4254|     66|  MZ_MACRO_END
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  726|     66|#define MZ_MACRO_END while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (726:29): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4268|     66|                      (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT)               \
  |  |  |  |  |  | 4269|     66|                          ? TINFL_STATUS_NEEDS_MORE_INPUT                      \
  |  |  |  |  |  | 4270|     66|                          : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS);         \
  |  |  |  |  |  | 4271|     66|    }                                                                          \
  |  |  |  |  |  | 4272|    127|    c = *pIn_buf_cur++;                                                        \
  |  |  |  |  |  | 4273|     61|  }                                                                            \
  |  |  |  |  |  | 4274|    299|  MZ_MACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  726|    299|#define MZ_MACRO_END while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (726:29): [Folded, False: 61]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 4328|    127|    bit_buf |= (((tinfl_bit_buf_t)c) << num_bits);                             \
  |  |  |  | 4329|     61|    num_bits += 8;                                                             \
  |  |  |  | 4330|     61|  } while (num_bits < 15);
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4330:12): [True: 30, False: 31]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 4354|    564|      } else {                                                                 \
  |  | 4355|    564|        bit_buf |= (((tinfl_bit_buf_t)pIn_buf_cur[0]) << num_bits) |           \
  |  | 4356|    564|                   (((tinfl_bit_buf_t)pIn_buf_cur[1]) << (num_bits + 8));      \
  |  | 4357|    564|        pIn_buf_cur += 2;                                                      \
  |  | 4358|    564|        num_bits += 16;                                                        \
  |  | 4359|    564|      }                                                                        \
  |  | 4360|    833|    }                                                                          \
  |  | 4361|   179k|    if ((temp = pLookUp[bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]) >= 0)         \
  |  |  ------------------
  |  |  |  Branch (4361:9): [True: 178k, False: 1.38k]
  |  |  ------------------
  |  | 4362|   179k|      code_len = temp >> 9, temp &= 511;                                       \
  |  | 4363|   179k|    else {                                                                     \
  |  | 4364|  1.38k|      code_len = TINFL_FAST_LOOKUP_BITS;                                       \
  |  | 4365|  5.99k|      do {                                                                     \
  |  | 4366|  5.99k|        temp = pTree[~temp + ((bit_buf >> code_len++) & 1)];                   \
  |  | 4367|  5.99k|      } while (temp < 0);                                                      \
  |  |  ------------------
  |  |  |  Branch (4367:16): [True: 4.61k, False: 1.38k]
  |  |  ------------------
  |  | 4368|  1.38k|    }                                                                          \
  |  | 4369|   179k|    sym = temp;                                                                \
  |  | 4370|   179k|    bit_buf >>= code_len;                                                      \
  |  | 4371|   179k|    num_bits -= code_len;                                                      \
  |  | 4372|   179k|  }                                                                            \
  |  | 4373|   179k|  MZ_MACRO_END
  |  |  ------------------
  |  |  |  |  726|   179k|#define MZ_MACRO_END while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (726:29): [Folded, False: 179k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 4712|   179k|        num_extra = s_dist_extra[dist];
 4713|   179k|        dist = s_dist_base[dist];
 4714|   179k|        if (num_extra) {
  ------------------
  |  Branch (4714:13): [True: 4.94k, False: 174k]
  ------------------
 4715|  4.94k|          mz_uint extra_bits;
 4716|  4.94k|          TINFL_GET_BITS(27, extra_bits, num_extra);
  ------------------
  |  | 4293|  4.94k|  do {                                                                         \
  |  | 4294|  4.94k|    if (num_bits < (mz_uint)(n)) {                                             \
  |  |  ------------------
  |  |  |  Branch (4294:9): [True: 238, False: 4.70k]
  |  |  ------------------
  |  | 4295|    238|      TINFL_NEED_BITS(state_index, n);                                         \
  |  |  ------------------
  |  |  |  | 4277|    247|  do {                                                                         \
  |  |  |  | 4278|    247|    mz_uint c;                                                                 \
  |  |  |  | 4279|    247|    TINFL_GET_BYTE(state_index, c);                                            \
  |  |  |  |  ------------------
  |  |  |  |  |  | 4265|    247|  do {                                                                         \
  |  |  |  |  |  | 4266|    247|    while (pIn_buf_cur >= pIn_buf_end) {                                       \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4266:12): [True: 32, False: 215]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4267|     32|      TINFL_CR_RETURN(state_index,                                             \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4248|     32|  do {                                                                         \
  |  |  |  |  |  |  |  | 4249|     64|    status = result;                                                           \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4249:14): [True: 0, False: 32]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4250|     32|    r->m_state = state_index;                                                  \
  |  |  |  |  |  |  |  | 4251|     32|    goto common_exit;                                                          \
  |  |  |  |  |  |  |  | 4252|     32|  case state_index:;                                                           \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4252:3): [True: 0, False: 1.04k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4253|      0|  }                                                                            \
  |  |  |  |  |  |  |  | 4254|     32|  MZ_MACRO_END
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  726|     32|#define MZ_MACRO_END while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (726:29): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4268|     32|                      (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT)               \
  |  |  |  |  |  | 4269|     32|                          ? TINFL_STATUS_NEEDS_MORE_INPUT                      \
  |  |  |  |  |  | 4270|     32|                          : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS);         \
  |  |  |  |  |  | 4271|     32|    }                                                                          \
  |  |  |  |  |  | 4272|    247|    c = *pIn_buf_cur++;                                                        \
  |  |  |  |  |  | 4273|    215|  }                                                                            \
  |  |  |  |  |  | 4274|    247|  MZ_MACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  726|    247|#define MZ_MACRO_END while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (726:29): [Folded, False: 215]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 4280|    247|    bit_buf |= (((tinfl_bit_buf_t)c) << num_bits);                             \
  |  |  |  | 4281|    215|    num_bits += 8;                                                             \
  |  |  |  | 4282|    215|  } while (num_bits < (mz_uint)(n))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4282:12): [True: 9, False: 206]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 4296|    238|    }                                                                          \
  |  | 4297|  4.94k|    b = bit_buf & ((1 << (n)) - 1);                                            \
  |  | 4298|  4.91k|    bit_buf >>= (n);                                                           \
  |  | 4299|  4.91k|    num_bits -= (n);                                                           \
  |  | 4300|  4.91k|  }                                                                            \
  |  | 4301|  4.94k|  MZ_MACRO_END
  |  |  ------------------
  |  |  |  |  726|  4.94k|#define MZ_MACRO_END while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (726:29): [Folded, False: 4.91k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 4717|  4.91k|          dist += extra_bits;
 4718|  4.91k|        }
 4719|       |
 4720|   179k|        dist_from_out_buf_start = pOut_buf_cur - pOut_buf_start;
 4721|   179k|        if ((dist == 0 || dist > dist_from_out_buf_start ||
  ------------------
  |  Branch (4721:14): [True: 20, False: 179k]
  |  Branch (4721:27): [True: 51, False: 179k]
  ------------------
 4722|   179k|             dist_from_out_buf_start == 0) &&
  ------------------
  |  Branch (4722:14): [True: 0, False: 179k]
  ------------------
 4723|     71|            (decomp_flags & TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF)) {
  ------------------
  |  Branch (4723:13): [True: 71, False: 0]
  ------------------
 4724|     71|          TINFL_CR_RETURN_FOREVER(37, TINFL_STATUS_FAILED);
  ------------------
  |  | 4256|     71|  do {                                                                         \
  |  | 4257|     71|    for (;;) {                                                                 \
  |  | 4258|     71|      TINFL_CR_RETURN(state_index, result);                                    \
  |  |  ------------------
  |  |  |  | 4248|     71|  do {                                                                         \
  |  |  |  | 4249|     71|    status = result;                                                           \
  |  |  |  | 4250|     71|    r->m_state = state_index;                                                  \
  |  |  |  | 4251|     71|    goto common_exit;                                                          \
  |  |  |  | 4252|     71|  case state_index:;                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4252:3): [True: 0, False: 1.04k]
  |  |  |  |  ------------------
  |  |  |  | 4253|      0|  }                                                                            \
  |  |  |  | 4254|     71|  MZ_MACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  726|     71|#define MZ_MACRO_END while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (726:29): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 4259|     71|    }                                                                          \
  |  | 4260|     71|  }                                                                            \
  |  | 4261|     71|  MZ_MACRO_END
  |  |  ------------------
  |  |  |  |  726|     71|#define MZ_MACRO_END while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (726:29): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 4725|     71|        }
 4726|       |
 4727|   179k|        pSrc = pOut_buf_start +
 4728|   179k|               ((dist_from_out_buf_start - dist) & out_buf_size_mask);
 4729|       |
 4730|   179k|        if ((MZ_MAX(pOut_buf_cur, pSrc) + counter) > pOut_buf_end) {
  ------------------
  |  |  758|   179k|#define MZ_MAX(a, b) (((a) > (b)) ? (a) : (b))
  |  |  ------------------
  |  |  |  Branch (758:23): [True: 179k, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (4730:13): [True: 47, False: 179k]
  ------------------
 4731|  1.42k|          while (counter--) {
  ------------------
  |  Branch (4731:18): [True: 1.42k, False: 0]
  ------------------
 4732|  1.42k|            while (pOut_buf_cur >= pOut_buf_end) {
  ------------------
  |  Branch (4732:20): [True: 47, False: 1.38k]
  ------------------
 4733|     47|              TINFL_CR_RETURN(53, TINFL_STATUS_HAS_MORE_OUTPUT);
  ------------------
  |  | 4248|     47|  do {                                                                         \
  |  | 4249|     47|    status = result;                                                           \
  |  | 4250|     47|    r->m_state = state_index;                                                  \
  |  | 4251|     47|    goto common_exit;                                                          \
  |  | 4252|     47|  case state_index:;                                                           \
  |  |  ------------------
  |  |  |  Branch (4252:3): [True: 0, False: 1.04k]
  |  |  ------------------
  |  | 4253|      0|  }                                                                            \
  |  | 4254|     47|  MZ_MACRO_END
  |  |  ------------------
  |  |  |  |  726|     47|#define MZ_MACRO_END while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (726:29): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 4734|     47|            }
 4735|  1.38k|            *pOut_buf_cur++ =
 4736|  1.38k|                pOut_buf_start[(dist_from_out_buf_start++ - dist) &
 4737|  1.38k|                               out_buf_size_mask];
 4738|  1.38k|          }
 4739|      0|          continue;
 4740|     47|        }
 4741|       |#if MINIZ_USE_UNALIGNED_LOADS_AND_STORES
 4742|       |        else if ((counter >= 9) && (counter <= dist)) {
 4743|       |          const mz_uint8 *pSrc_end = pSrc + (counter & ~7);
 4744|       |          do {
 4745|       |#ifdef MINIZ_UNALIGNED_USE_MEMCPY
 4746|       |            memcpy(pOut_buf_cur, pSrc, sizeof(mz_uint32) * 2);
 4747|       |#else
 4748|       |            ((mz_uint32 *)pOut_buf_cur)[0] = ((const mz_uint32 *)pSrc)[0];
 4749|       |            ((mz_uint32 *)pOut_buf_cur)[1] = ((const mz_uint32 *)pSrc)[1];
 4750|       |#endif
 4751|       |            pOut_buf_cur += 8;
 4752|       |          } while ((pSrc += 8) < pSrc_end);
 4753|       |          if ((counter &= 7) < 3) {
 4754|       |            if (counter) {
 4755|       |              pOut_buf_cur[0] = pSrc[0];
 4756|       |              if (counter > 1)
 4757|       |                pOut_buf_cur[1] = pSrc[1];
 4758|       |              pOut_buf_cur += counter;
 4759|       |            }
 4760|       |            continue;
 4761|       |          }
 4762|       |        }
 4763|       |#endif
 4764|  5.79M|        while (counter > 2) {
  ------------------
  |  Branch (4764:16): [True: 5.61M, False: 179k]
  ------------------
 4765|  5.61M|          pOut_buf_cur[0] = pSrc[0];
 4766|  5.61M|          pOut_buf_cur[1] = pSrc[1];
 4767|  5.61M|          pOut_buf_cur[2] = pSrc[2];
 4768|  5.61M|          pOut_buf_cur += 3;
 4769|  5.61M|          pSrc += 3;
 4770|  5.61M|          counter -= 3;
 4771|  5.61M|        }
 4772|   179k|        if (counter > 0) {
  ------------------
  |  Branch (4772:13): [True: 117k, False: 62.6k]
  ------------------
 4773|   117k|          pOut_buf_cur[0] = pSrc[0];
 4774|   117k|          if (counter > 1)
  ------------------
  |  Branch (4774:15): [True: 91.5k, False: 25.4k]
  ------------------
 4775|  91.5k|            pOut_buf_cur[1] = pSrc[1];
 4776|   117k|          pOut_buf_cur += counter;
 4777|   117k|        }
 4778|   179k|      }
 4779|  2.64k|    }
 4780|  3.78k|  } while (!(r->m_final & 1));
  ------------------
  |  Branch (4780:12): [True: 2.77k, False: 133]
  ------------------
 4781|       |
 4782|       |  /* Ensure byte alignment and put back any bytes from the bitbuf if we've
 4783|       |   * looked ahead too far on gzip, or other Deflate streams followed by
 4784|       |   * arbitrary data. */
 4785|       |  /* I'm being super conservative here. A number of simplifications can be made
 4786|       |   * to the byte alignment part, and the Adler32 check shouldn't ever need to
 4787|       |   * worry about reading from the bitbuf now. */
 4788|    133|  TINFL_SKIP_BITS(32, num_bits & 7);
  ------------------
  |  | 4284|    133|  do {                                                                         \
  |  | 4285|    133|    if (num_bits < (mz_uint)(n)) {                                             \
  |  |  ------------------
  |  |  |  Branch (4285:9): [True: 0, False: 133]
  |  |  ------------------
  |  | 4286|      0|      TINFL_NEED_BITS(state_index, n);                                         \
  |  |  ------------------
  |  |  |  | 4277|      0|  do {                                                                         \
  |  |  |  | 4278|      0|    mz_uint c;                                                                 \
  |  |  |  | 4279|      0|    TINFL_GET_BYTE(state_index, c);                                            \
  |  |  |  |  ------------------
  |  |  |  |  |  | 4265|      0|  do {                                                                         \
  |  |  |  |  |  | 4266|      0|    while (pIn_buf_cur >= pIn_buf_end) {                                       \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4266:12): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4267|      0|      TINFL_CR_RETURN(state_index,                                             \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4248|      0|  do {                                                                         \
  |  |  |  |  |  |  |  | 4249|      0|    status = result;                                                           \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4249:14): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4250|      0|    r->m_state = state_index;                                                  \
  |  |  |  |  |  |  |  | 4251|      0|    goto common_exit;                                                          \
  |  |  |  |  |  |  |  | 4252|      0|  case state_index:;                                                           \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4252:3): [True: 0, False: 1.04k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4253|      0|  }                                                                            \
  |  |  |  |  |  |  |  | 4254|      0|  MZ_MACRO_END
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  726|      0|#define MZ_MACRO_END while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (726:29): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4268|      0|                      (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT)               \
  |  |  |  |  |  | 4269|      0|                          ? TINFL_STATUS_NEEDS_MORE_INPUT                      \
  |  |  |  |  |  | 4270|      0|                          : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS);         \
  |  |  |  |  |  | 4271|      0|    }                                                                          \
  |  |  |  |  |  | 4272|      0|    c = *pIn_buf_cur++;                                                        \
  |  |  |  |  |  | 4273|      0|  }                                                                            \
  |  |  |  |  |  | 4274|      0|  MZ_MACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  726|      0|#define MZ_MACRO_END while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (726:29): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 4280|      0|    bit_buf |= (((tinfl_bit_buf_t)c) << num_bits);                             \
  |  |  |  | 4281|      0|    num_bits += 8;                                                             \
  |  |  |  | 4282|      0|  } while (num_bits < (mz_uint)(n))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4282:12): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 4287|      0|    }                                                                          \
  |  | 4288|    133|    bit_buf >>= (n);                                                           \
  |  | 4289|    133|    num_bits -= (n);                                                           \
  |  | 4290|    133|  }                                                                            \
  |  | 4291|  1.04k|  MZ_MACRO_END
  |  |  ------------------
  |  |  |  |  726|  1.04k|#define MZ_MACRO_END while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (726:29): [Folded, False: 133]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 4789|    438|  while ((pIn_buf_cur > pIn_buf_next) && (num_bits >= 8)) {
  ------------------
  |  Branch (4789:10): [True: 438, False: 0]
  |  Branch (4789:42): [True: 305, False: 133]
  ------------------
 4790|    305|    --pIn_buf_cur;
 4791|    305|    num_bits -= 8;
 4792|    305|  }
 4793|    133|  bit_buf &= ~(~(tinfl_bit_buf_t)0 << num_bits);
 4794|    133|  MZ_ASSERT(!num_bits); /* if this assert fires then we've read beyond the end
  ------------------
  |  |  746|    133|#define MZ_ASSERT(x) assert(x)
  ------------------
 4795|       |                           of non-deflate/zlib streams with following data (such
 4796|       |                           as gzip streams). */
 4797|       |
 4798|    133|  if (decomp_flags & TINFL_FLAG_PARSE_ZLIB_HEADER) {
  ------------------
  |  Branch (4798:7): [True: 0, False: 133]
  ------------------
 4799|      0|    for (counter = 0; counter < 4; ++counter) {
  ------------------
  |  Branch (4799:23): [True: 0, False: 0]
  ------------------
 4800|      0|      mz_uint s;
 4801|      0|      if (num_bits)
  ------------------
  |  Branch (4801:11): [True: 0, False: 0]
  ------------------
 4802|      0|        TINFL_GET_BITS(41, s, 8);
  ------------------
  |  | 4293|      0|  do {                                                                         \
  |  | 4294|      0|    if (num_bits < (mz_uint)(n)) {                                             \
  |  |  ------------------
  |  |  |  Branch (4294:9): [True: 0, False: 0]
  |  |  ------------------
  |  | 4295|      0|      TINFL_NEED_BITS(state_index, n);                                         \
  |  |  ------------------
  |  |  |  | 4277|      0|  do {                                                                         \
  |  |  |  | 4278|      0|    mz_uint c;                                                                 \
  |  |  |  | 4279|      0|    TINFL_GET_BYTE(state_index, c);                                            \
  |  |  |  |  ------------------
  |  |  |  |  |  | 4265|      0|  do {                                                                         \
  |  |  |  |  |  | 4266|      0|    while (pIn_buf_cur >= pIn_buf_end) {                                       \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4266:12): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4267|      0|      TINFL_CR_RETURN(state_index,                                             \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4248|      0|  do {                                                                         \
  |  |  |  |  |  |  |  | 4249|      0|    status = result;                                                           \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4249:14): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4250|      0|    r->m_state = state_index;                                                  \
  |  |  |  |  |  |  |  | 4251|      0|    goto common_exit;                                                          \
  |  |  |  |  |  |  |  | 4252|      0|  case state_index:;                                                           \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4252:3): [True: 0, False: 1.04k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4253|      0|  }                                                                            \
  |  |  |  |  |  |  |  | 4254|      0|  MZ_MACRO_END
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  726|      0|#define MZ_MACRO_END while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (726:29): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4268|      0|                      (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT)               \
  |  |  |  |  |  | 4269|      0|                          ? TINFL_STATUS_NEEDS_MORE_INPUT                      \
  |  |  |  |  |  | 4270|      0|                          : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS);         \
  |  |  |  |  |  | 4271|      0|    }                                                                          \
  |  |  |  |  |  | 4272|      0|    c = *pIn_buf_cur++;                                                        \
  |  |  |  |  |  | 4273|      0|  }                                                                            \
  |  |  |  |  |  | 4274|      0|  MZ_MACRO_END
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  726|      0|#define MZ_MACRO_END while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (726:29): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 4280|      0|    bit_buf |= (((tinfl_bit_buf_t)c) << num_bits);                             \
  |  |  |  | 4281|      0|    num_bits += 8;                                                             \
  |  |  |  | 4282|      0|  } while (num_bits < (mz_uint)(n))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4282:12): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 4296|      0|    }                                                                          \
  |  | 4297|      0|    b = bit_buf & ((1 << (n)) - 1);                                            \
  |  | 4298|      0|    bit_buf >>= (n);                                                           \
  |  | 4299|      0|    num_bits -= (n);                                                           \
  |  | 4300|      0|  }                                                                            \
  |  | 4301|      0|  MZ_MACRO_END
  |  |  ------------------
  |  |  |  |  726|      0|#define MZ_MACRO_END while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (726:29): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 4803|      0|      else
 4804|      0|        TINFL_GET_BYTE(42, s);
  ------------------
  |  | 4265|      0|  do {                                                                         \
  |  | 4266|      0|    while (pIn_buf_cur >= pIn_buf_end) {                                       \
  |  |  ------------------
  |  |  |  Branch (4266:12): [True: 0, False: 0]
  |  |  ------------------
  |  | 4267|      0|      TINFL_CR_RETURN(state_index,                                             \
  |  |  ------------------
  |  |  |  | 4248|      0|  do {                                                                         \
  |  |  |  | 4249|      0|    status = result;                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4249:14): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 4250|      0|    r->m_state = state_index;                                                  \
  |  |  |  | 4251|      0|    goto common_exit;                                                          \
  |  |  |  | 4252|      0|  case state_index:;                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4252:3): [True: 0, False: 1.04k]
  |  |  |  |  ------------------
  |  |  |  | 4253|      0|  }                                                                            \
  |  |  |  | 4254|      0|  MZ_MACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  726|      0|#define MZ_MACRO_END while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (726:29): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 4268|      0|                      (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT)               \
  |  | 4269|      0|                          ? TINFL_STATUS_NEEDS_MORE_INPUT                      \
  |  | 4270|      0|                          : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS);         \
  |  | 4271|      0|    }                                                                          \
  |  | 4272|      0|    c = *pIn_buf_cur++;                                                        \
  |  | 4273|      0|  }                                                                            \
  |  | 4274|      0|  MZ_MACRO_END
  |  |  ------------------
  |  |  |  |  726|      0|#define MZ_MACRO_END while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (726:29): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 4805|      0|      r->m_z_adler32 = (r->m_z_adler32 << 8) | s;
 4806|      0|    }
 4807|      0|  }
 4808|  1.04k|  TINFL_CR_RETURN_FOREVER(34, TINFL_STATUS_DONE);
  ------------------
  |  | 4256|    133|  do {                                                                         \
  |  | 4257|    133|    for (;;) {                                                                 \
  |  | 4258|    133|      TINFL_CR_RETURN(state_index, result);                                    \
  |  |  ------------------
  |  |  |  | 4248|    133|  do {                                                                         \
  |  |  |  | 4249|    133|    status = result;                                                           \
  |  |  |  | 4250|    133|    r->m_state = state_index;                                                  \
  |  |  |  | 4251|    133|    goto common_exit;                                                          \
  |  |  |  | 4252|    133|  case state_index:;                                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4252:3): [True: 0, False: 1.04k]
  |  |  |  |  ------------------
  |  |  |  | 4253|      0|  }                                                                            \
  |  |  |  | 4254|    133|  MZ_MACRO_END
  |  |  |  |  ------------------
  |  |  |  |  |  |  726|    133|#define MZ_MACRO_END while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (726:29): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 4259|    133|    }                                                                          \
  |  | 4260|    133|  }                                                                            \
  |  | 4261|    133|  MZ_MACRO_END
  |  |  ------------------
  |  |  |  |  726|    133|#define MZ_MACRO_END while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (726:29): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 4809|       |
 4810|  1.04k|  TINFL_CR_FINISH
  ------------------
  |  | 4262|  1.04k|#define TINFL_CR_FINISH }
  ------------------
 4811|       |
 4812|  1.04k|common_exit:
 4813|       |  /* As long as we aren't telling the caller that we NEED more input to make
 4814|       |   * forward progress: */
 4815|       |  /* Put back any bytes from the bitbuf in case we've looked ahead too far on
 4816|       |   * gzip, or other Deflate streams followed by arbitrary data. */
 4817|       |  /* We need to be very careful here to NOT push back any bytes we definitely
 4818|       |   * know we need to make forward progress, though, or we'll lock the caller up
 4819|       |   * into an inf loop. */
 4820|  1.04k|  if ((status != TINFL_STATUS_NEEDS_MORE_INPUT) &&
  ------------------
  |  Branch (4820:7): [True: 1.04k, False: 0]
  ------------------
 4821|  1.04k|      (status != TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS)) {
  ------------------
  |  Branch (4821:7): [True: 638, False: 407]
  ------------------
 4822|  1.62k|    while ((pIn_buf_cur > pIn_buf_next) && (num_bits >= 8)) {
  ------------------
  |  Branch (4822:12): [True: 1.62k, False: 0]
  |  Branch (4822:44): [True: 983, False: 638]
  ------------------
 4823|    983|      --pIn_buf_cur;
 4824|    983|      num_bits -= 8;
 4825|    983|    }
 4826|    638|  }
 4827|  1.04k|  r->m_num_bits = num_bits;
 4828|  1.04k|  r->m_bit_buf = bit_buf & ~(~(tinfl_bit_buf_t)0 << num_bits);
 4829|  1.04k|  r->m_dist = dist;
 4830|  1.04k|  r->m_counter = counter;
 4831|  1.04k|  r->m_num_extra = num_extra;
 4832|  1.04k|  r->m_dist_from_out_buf_start = dist_from_out_buf_start;
 4833|  1.04k|  *pIn_buf_size = pIn_buf_cur - pIn_buf_next;
 4834|  1.04k|  *pOut_buf_size = pOut_buf_cur - pOut_buf_next;
 4835|  1.04k|  if ((decomp_flags &
  ------------------
  |  Branch (4835:7): [True: 0, False: 1.04k]
  ------------------
 4836|  1.04k|       (TINFL_FLAG_PARSE_ZLIB_HEADER | TINFL_FLAG_COMPUTE_ADLER32)) &&
 4837|      0|      (status >= 0)) {
  ------------------
  |  Branch (4837:7): [True: 0, False: 0]
  ------------------
 4838|      0|    const mz_uint8 *ptr = pOut_buf_next;
 4839|      0|    size_t buf_len = *pOut_buf_size;
 4840|      0|    mz_uint32 i, s1 = r->m_check_adler32 & 0xffff,
 4841|      0|                 s2 = r->m_check_adler32 >> 16;
 4842|      0|    size_t block_len = buf_len % 5552;
 4843|      0|    while (buf_len) {
  ------------------
  |  Branch (4843:12): [True: 0, False: 0]
  ------------------
 4844|      0|      for (i = 0; i + 7 < block_len; i += 8, ptr += 8) {
  ------------------
  |  Branch (4844:19): [True: 0, False: 0]
  ------------------
 4845|      0|        s1 += ptr[0], s2 += s1;
 4846|      0|        s1 += ptr[1], s2 += s1;
 4847|      0|        s1 += ptr[2], s2 += s1;
 4848|      0|        s1 += ptr[3], s2 += s1;
 4849|      0|        s1 += ptr[4], s2 += s1;
 4850|      0|        s1 += ptr[5], s2 += s1;
 4851|      0|        s1 += ptr[6], s2 += s1;
 4852|      0|        s1 += ptr[7], s2 += s1;
 4853|      0|      }
 4854|      0|      for (; i < block_len; ++i)
  ------------------
  |  Branch (4854:14): [True: 0, False: 0]
  ------------------
 4855|      0|        s1 += *ptr++, s2 += s1;
 4856|      0|      s1 %= 65521U, s2 %= 65521U;
 4857|      0|      buf_len -= block_len;
 4858|      0|      block_len = 5552;
 4859|      0|    }
 4860|      0|    r->m_check_adler32 = (s2 << 16) + s1;
 4861|      0|    if ((status == TINFL_STATUS_DONE) &&
  ------------------
  |  Branch (4861:9): [True: 0, False: 0]
  ------------------
 4862|      0|        (decomp_flags & TINFL_FLAG_PARSE_ZLIB_HEADER) &&
  ------------------
  |  Branch (4862:9): [True: 0, False: 0]
  ------------------
 4863|      0|        (r->m_check_adler32 != r->m_z_adler32))
  ------------------
  |  Branch (4863:9): [True: 0, False: 0]
  ------------------
 4864|      0|      status = TINFL_STATUS_ADLER32_MISMATCH;
 4865|      0|  }
 4866|  1.04k|  return status;
 4867|  1.04k|}
mz_zip_reader_end:
 6094|  2.43k|mz_bool mz_zip_reader_end(mz_zip_archive *pZip) {
 6095|  2.43k|  return mz_zip_reader_end_internal(pZip, MZ_TRUE);
  ------------------
  |  |  719|  2.43k|#define MZ_TRUE (1)
  ------------------
 6096|  2.43k|}
mz_zip_reader_init_mem:
 6127|  3.75k|                               size_t size, mz_uint flags) {
 6128|  3.75k|  if (!pMem)
  ------------------
  |  Branch (6128:7): [True: 0, False: 3.75k]
  ------------------
 6129|      0|    return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
 6130|       |
 6131|  3.75k|  if (size < MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE)
  ------------------
  |  Branch (6131:7): [True: 10, False: 3.74k]
  ------------------
 6132|     10|    return mz_zip_set_error(pZip, MZ_ZIP_NOT_AN_ARCHIVE);
 6133|       |
 6134|  3.74k|  if (!mz_zip_reader_init_internal(pZip, flags))
  ------------------
  |  Branch (6134:7): [True: 0, False: 3.74k]
  ------------------
 6135|      0|    return MZ_FALSE;
  ------------------
  |  |  718|      0|#define MZ_FALSE (0)
  ------------------
 6136|       |
 6137|  3.74k|  pZip->m_zip_type = MZ_ZIP_TYPE_MEMORY;
 6138|  3.74k|  pZip->m_archive_size = size;
 6139|  3.74k|  pZip->m_pRead = mz_zip_mem_read_func;
 6140|  3.74k|  pZip->m_pIO_opaque = pZip;
 6141|  3.74k|  pZip->m_pNeeds_keepalive = NULL;
 6142|       |
 6143|       |#ifdef __cplusplus
 6144|       |  pZip->m_pState->m_pMem = const_cast<void *>(pMem);
 6145|       |#else
 6146|  3.74k|  pZip->m_pState->m_pMem = (void *)pMem;
 6147|  3.74k|#endif
 6148|       |
 6149|  3.74k|  pZip->m_pState->m_mem_size = size;
 6150|       |
 6151|  3.74k|  if (!mz_zip_reader_read_central_dir(pZip, flags)) {
  ------------------
  |  Branch (6151:7): [True: 1.31k, False: 2.43k]
  ------------------
 6152|  1.31k|    mz_zip_reader_end_internal(pZip, MZ_FALSE);
  ------------------
  |  |  718|  1.31k|#define MZ_FALSE (0)
  ------------------
 6153|  1.31k|    return MZ_FALSE;
  ------------------
  |  |  718|  1.31k|#define MZ_FALSE (0)
  ------------------
 6154|  1.31k|  }
 6155|       |
 6156|  2.43k|  return MZ_TRUE;
  ------------------
  |  |  719|  2.43k|#define MZ_TRUE (1)
  ------------------
 6157|  3.74k|}
mz_zip_reader_is_file_encrypted:
 6285|  8.75k|                                        mz_uint file_index) {
 6286|  8.75k|  mz_uint m_bit_flag;
 6287|  8.75k|  const mz_uint8 *p = mz_zip_get_cdh(pZip, file_index);
 6288|  8.75k|  if (!p) {
  ------------------
  |  Branch (6288:7): [True: 0, False: 8.75k]
  ------------------
 6289|      0|    mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
 6290|      0|    return MZ_FALSE;
  ------------------
  |  |  718|      0|#define MZ_FALSE (0)
  ------------------
 6291|      0|  }
 6292|       |
 6293|  8.75k|  m_bit_flag = MZ_READ_LE16(p + MZ_ZIP_CDH_BIT_FLAG_OFS);
  ------------------
  |  |  769|  8.75k|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  770|  8.75k|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U))
  ------------------
 6294|  8.75k|  return (m_bit_flag &
 6295|  8.75k|          (MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_IS_ENCRYPTED |
 6296|  8.75k|           MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_USES_STRONG_ENCRYPTION)) != 0;
 6297|  8.75k|}
mz_zip_reader_is_file_supported:
 6300|  8.75k|                                        mz_uint file_index) {
 6301|  8.75k|  mz_uint bit_flag;
 6302|  8.75k|  mz_uint method;
 6303|       |
 6304|  8.75k|  const mz_uint8 *p = mz_zip_get_cdh(pZip, file_index);
 6305|  8.75k|  if (!p) {
  ------------------
  |  Branch (6305:7): [True: 0, False: 8.75k]
  ------------------
 6306|      0|    mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
 6307|      0|    return MZ_FALSE;
  ------------------
  |  |  718|      0|#define MZ_FALSE (0)
  ------------------
 6308|      0|  }
 6309|       |
 6310|  8.75k|  method = MZ_READ_LE16(p + MZ_ZIP_CDH_METHOD_OFS);
  ------------------
  |  |  769|  8.75k|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  770|  8.75k|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U))
  ------------------
 6311|  8.75k|  bit_flag = MZ_READ_LE16(p + MZ_ZIP_CDH_BIT_FLAG_OFS);
  ------------------
  |  |  769|  8.75k|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  770|  8.75k|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U))
  ------------------
 6312|       |
 6313|  8.75k|  if ((method != 0) && (method != MZ_DEFLATED)) {
  ------------------
  |  |  316|  5.67k|#define MZ_DEFLATED 8
  ------------------
  |  Branch (6313:7): [True: 5.67k, False: 3.08k]
  |  Branch (6313:24): [True: 2.09k, False: 3.57k]
  ------------------
 6314|  2.09k|    mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_METHOD);
 6315|  2.09k|    return MZ_FALSE;
  ------------------
  |  |  718|  2.09k|#define MZ_FALSE (0)
  ------------------
 6316|  2.09k|  }
 6317|       |
 6318|  6.66k|  if (bit_flag & (MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_IS_ENCRYPTED |
  ------------------
  |  Branch (6318:7): [True: 903, False: 5.75k]
  ------------------
 6319|  6.66k|                  MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_USES_STRONG_ENCRYPTION)) {
 6320|    903|    mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_ENCRYPTION);
 6321|    903|    return MZ_FALSE;
  ------------------
  |  |  718|    903|#define MZ_FALSE (0)
  ------------------
 6322|    903|  }
 6323|       |
 6324|  5.75k|  if (bit_flag & MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_COMPRESSED_PATCH_FLAG) {
  ------------------
  |  Branch (6324:7): [True: 216, False: 5.54k]
  ------------------
 6325|    216|    mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_FEATURE);
 6326|    216|    return MZ_FALSE;
  ------------------
  |  |  718|    216|#define MZ_FALSE (0)
  ------------------
 6327|    216|  }
 6328|       |
 6329|  5.54k|  return MZ_TRUE;
  ------------------
  |  |  719|  5.54k|#define MZ_TRUE (1)
  ------------------
 6330|  5.75k|}
mz_zip_reader_is_file_a_directory:
 6333|  8.75k|                                          mz_uint file_index) {
 6334|  8.75k|  mz_uint filename_len, attribute_mapping_id, external_attr;
 6335|  8.75k|  const mz_uint8 *p = mz_zip_get_cdh(pZip, file_index);
 6336|  8.75k|  if (!p) {
  ------------------
  |  Branch (6336:7): [True: 0, False: 8.75k]
  ------------------
 6337|      0|    mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
 6338|      0|    return MZ_FALSE;
  ------------------
  |  |  718|      0|#define MZ_FALSE (0)
  ------------------
 6339|      0|  }
 6340|       |
 6341|  8.75k|  filename_len = MZ_READ_LE16(p + MZ_ZIP_CDH_FILENAME_LEN_OFS);
  ------------------
  |  |  769|  8.75k|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  770|  8.75k|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U))
  ------------------
 6342|  8.75k|  if (filename_len) {
  ------------------
  |  Branch (6342:7): [True: 8.53k, False: 220]
  ------------------
 6343|  8.53k|    if (*(p + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + filename_len - 1) == '/')
  ------------------
  |  Branch (6343:9): [True: 23, False: 8.51k]
  ------------------
 6344|     23|      return MZ_TRUE;
  ------------------
  |  |  719|     23|#define MZ_TRUE (1)
  ------------------
 6345|  8.53k|  }
 6346|       |
 6347|       |  /* Bugfix: This code was also checking if the internal attribute was non-zero,
 6348|       |   * which wasn't correct. */
 6349|       |  /* Most/all zip writers (hopefully) set DOS file/directory attributes in the
 6350|       |   * low 16-bits, so check for the DOS directory flag and ignore the source OS
 6351|       |   * ID in the created by field. */
 6352|       |  /* FIXME: Remove this check? Is it necessary - we already check the filename.
 6353|       |   */
 6354|  8.73k|  attribute_mapping_id = MZ_READ_LE16(p + MZ_ZIP_CDH_VERSION_MADE_BY_OFS) >> 8;
  ------------------
  |  |  769|  8.73k|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  770|  8.73k|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U))
  ------------------
 6355|  8.73k|  (void)attribute_mapping_id;
 6356|       |
 6357|  8.73k|  external_attr = MZ_READ_LE32(p + MZ_ZIP_CDH_EXTERNAL_ATTR_OFS);
  ------------------
  |  |  772|  8.73k|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  773|  8.73k|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) |                           \
  |  |  774|  8.73k|   ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) |                          \
  |  |  775|  8.73k|   ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U))
  ------------------
 6358|  8.73k|  if ((external_attr & MZ_ZIP_DOS_DIR_ATTRIBUTE_BITFLAG) != 0) {
  ------------------
  |  Branch (6358:7): [True: 2.49k, False: 6.24k]
  ------------------
 6359|  2.49k|    return MZ_TRUE;
  ------------------
  |  |  719|  2.49k|#define MZ_TRUE (1)
  ------------------
 6360|  2.49k|  }
 6361|       |
 6362|  6.24k|  return MZ_FALSE;
  ------------------
  |  |  718|  6.24k|#define MZ_FALSE (0)
  ------------------
 6363|  8.73k|}
mz_zip_reader_locate_file:
 6570|  3.03k|                              const char *pComment, mz_uint flags) {
 6571|  3.03k|  mz_uint32 index;
 6572|  3.03k|  if (!mz_zip_reader_locate_file_v2(pZip, pName, pComment, flags, &index))
  ------------------
  |  Branch (6572:7): [True: 565, False: 2.46k]
  ------------------
 6573|    565|    return -1;
 6574|  2.46k|  else
 6575|  2.46k|    return (int)index;
 6576|  3.03k|}
mz_zip_reader_locate_file_v2:
 6580|  3.03k|                                     mz_uint32 *pIndex) {
 6581|  3.03k|  mz_uint file_index;
 6582|  3.03k|  size_t name_len, comment_len;
 6583|       |
 6584|  3.03k|  if (pIndex)
  ------------------
  |  Branch (6584:7): [True: 3.03k, False: 0]
  ------------------
 6585|  3.03k|    *pIndex = 0;
 6586|       |
 6587|  3.03k|  if ((!pZip) || (!pZip->m_pState) || (!pName))
  ------------------
  |  Branch (6587:7): [True: 0, False: 3.03k]
  |  Branch (6587:18): [True: 0, False: 3.03k]
  |  Branch (6587:39): [True: 0, False: 3.03k]
  ------------------
 6588|      0|    return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
 6589|       |
 6590|       |  /* See if we can use a binary search */
 6591|  3.03k|  if (((pZip->m_pState->m_init_flags &
  ------------------
  |  Branch (6591:7): [True: 3.03k, False: 0]
  ------------------
 6592|  3.03k|        MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY) == 0) &&
 6593|  3.03k|      (pZip->m_zip_mode == MZ_ZIP_MODE_READING) &&
  ------------------
  |  Branch (6593:7): [True: 3.03k, False: 0]
  ------------------
 6594|  3.03k|      ((flags & (MZ_ZIP_FLAG_IGNORE_PATH | MZ_ZIP_FLAG_CASE_SENSITIVE)) == 0) &&
  ------------------
  |  Branch (6594:7): [True: 0, False: 3.03k]
  ------------------
 6595|      0|      (!pComment) && (pZip->m_pState->m_sorted_central_dir_offsets.m_size)) {
  ------------------
  |  Branch (6595:7): [True: 0, False: 0]
  |  Branch (6595:22): [True: 0, False: 0]
  ------------------
 6596|      0|    return mz_zip_locate_file_binary_search(pZip, pName, pIndex);
 6597|      0|  }
 6598|       |
 6599|       |  /* Locate the entry by scanning the entire central directory */
 6600|  3.03k|  name_len = strlen(pName);
 6601|  3.03k|  if (name_len > MZ_UINT16_MAX)
  ------------------
  |  |  793|  3.03k|#define MZ_UINT16_MAX (0xFFFFU)
  ------------------
  |  Branch (6601:7): [True: 0, False: 3.03k]
  ------------------
 6602|      0|    return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
 6603|       |
 6604|  3.03k|  comment_len = pComment ? strlen(pComment) : 0;
  ------------------
  |  Branch (6604:17): [True: 0, False: 3.03k]
  ------------------
 6605|  3.03k|  if (comment_len > MZ_UINT16_MAX)
  ------------------
  |  |  793|  3.03k|#define MZ_UINT16_MAX (0xFFFFU)
  ------------------
  |  Branch (6605:7): [True: 0, False: 3.03k]
  ------------------
 6606|      0|    return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
 6607|       |
 6608|  6.39k|  for (file_index = 0; file_index < pZip->m_total_files; file_index++) {
  ------------------
  |  Branch (6608:24): [True: 5.82k, False: 565]
  ------------------
 6609|  5.82k|    const mz_uint8 *pHeader = &MZ_ZIP_ARRAY_ELEMENT(
  ------------------
  |  | 5355|  5.82k|  ((element_type *)((array_ptr)->m_p))[index]
  ------------------
 6610|  5.82k|        &pZip->m_pState->m_central_dir, mz_uint8,
 6611|  5.82k|        MZ_ZIP_ARRAY_ELEMENT(&pZip->m_pState->m_central_dir_offsets, mz_uint32,
 6612|  5.82k|                             file_index));
 6613|  5.82k|    mz_uint filename_len = MZ_READ_LE16(pHeader + MZ_ZIP_CDH_FILENAME_LEN_OFS);
  ------------------
  |  |  769|  5.82k|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  770|  5.82k|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U))
  ------------------
 6614|  5.82k|    const char *pFilename =
 6615|  5.82k|        (const char *)pHeader + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE;
 6616|  5.82k|    if (filename_len < name_len)
  ------------------
  |  Branch (6616:9): [True: 426, False: 5.40k]
  ------------------
 6617|    426|      continue;
 6618|  5.40k|    if (comment_len) {
  ------------------
  |  Branch (6618:9): [True: 0, False: 5.40k]
  ------------------
 6619|      0|      mz_uint file_extra_len = MZ_READ_LE16(pHeader + MZ_ZIP_CDH_EXTRA_LEN_OFS),
  ------------------
  |  |  769|      0|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  770|      0|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U))
  ------------------
 6620|      0|              file_comment_len =
 6621|      0|                  MZ_READ_LE16(pHeader + MZ_ZIP_CDH_COMMENT_LEN_OFS);
  ------------------
  |  |  769|      0|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  770|      0|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U))
  ------------------
 6622|      0|      const char *pFile_comment = pFilename + filename_len + file_extra_len;
 6623|      0|      if ((file_comment_len != comment_len) ||
  ------------------
  |  Branch (6623:11): [True: 0, False: 0]
  ------------------
 6624|      0|          (!mz_zip_string_equal(pComment, pFile_comment, file_comment_len,
  ------------------
  |  Branch (6624:11): [True: 0, False: 0]
  ------------------
 6625|      0|                                flags)))
 6626|      0|        continue;
 6627|      0|    }
 6628|  5.40k|    if ((flags & MZ_ZIP_FLAG_IGNORE_PATH) && (filename_len)) {
  ------------------
  |  Branch (6628:9): [True: 0, False: 5.40k]
  |  Branch (6628:46): [True: 0, False: 0]
  ------------------
 6629|      0|      int ofs = filename_len - 1;
 6630|      0|      do {
 6631|      0|        if ((pFilename[ofs] == '/') || (pFilename[ofs] == '\\') ||
  ------------------
  |  Branch (6631:13): [True: 0, False: 0]
  |  Branch (6631:40): [True: 0, False: 0]
  ------------------
 6632|      0|            (pFilename[ofs] == ':'))
  ------------------
  |  Branch (6632:13): [True: 0, False: 0]
  ------------------
 6633|      0|          break;
 6634|      0|      } while (--ofs >= 0);
  ------------------
  |  Branch (6634:16): [True: 0, False: 0]
  ------------------
 6635|      0|      ofs++;
 6636|      0|      pFilename += ofs;
 6637|      0|      filename_len -= ofs;
 6638|      0|    }
 6639|  5.40k|    if ((filename_len == name_len) &&
  ------------------
  |  Branch (6639:9): [True: 2.97k, False: 2.42k]
  ------------------
 6640|  2.97k|        (mz_zip_string_equal(pName, pFilename, filename_len, flags))) {
  ------------------
  |  Branch (6640:9): [True: 2.46k, False: 509]
  ------------------
 6641|  2.46k|      if (pIndex)
  ------------------
  |  Branch (6641:11): [True: 2.46k, False: 0]
  ------------------
 6642|  2.46k|        *pIndex = file_index;
 6643|  2.46k|      return MZ_TRUE;
  ------------------
  |  |  719|  2.46k|#define MZ_TRUE (1)
  ------------------
 6644|  2.46k|    }
 6645|  5.40k|  }
 6646|       |
 6647|    565|  return mz_zip_set_error(pZip, MZ_ZIP_FILE_NOT_FOUND);
 6648|  3.03k|}
mz_zip_reader_extract_to_mem_no_alloc:
 6814|  2.45k|                                              size_t user_read_buf_size) {
 6815|  2.45k|  return mz_zip_reader_extract_to_mem_no_alloc1(pZip, file_index, pBuf,
 6816|  2.45k|                                                buf_size, flags, pUser_read_buf,
 6817|       |                                                user_read_buf_size, NULL);
 6818|  2.45k|}
mz_zip_reader_file_stat:
10220|  8.75k|                                mz_zip_archive_file_stat *pStat) {
10221|  8.75k|  return mz_zip_file_stat_internal(
10222|       |      pZip, file_index, mz_zip_get_cdh(pZip, file_index), pStat, NULL);
10223|  8.75k|}
zip.c:tinfl_clear_tree:
 4375|  5.85k|static void tinfl_clear_tree(tinfl_decompressor *r) {
 4376|  5.85k|  if (r->m_type == 0)
  ------------------
  |  Branch (4376:7): [True: 2.68k, False: 3.17k]
  ------------------
 4377|  2.68k|    MZ_CLEAR_ARR(r->m_tree_0);
  ------------------
  |  |  761|  2.68k|#define MZ_CLEAR_ARR(obj) memset((obj), 0, sizeof(obj))
  ------------------
 4378|  3.17k|  else if (r->m_type == 1)
  ------------------
  |  Branch (4378:12): [True: 2.68k, False: 490]
  ------------------
 4379|  2.68k|    MZ_CLEAR_ARR(r->m_tree_1);
  ------------------
  |  |  761|  2.68k|#define MZ_CLEAR_ARR(obj) memset((obj), 0, sizeof(obj))
  ------------------
 4380|    490|  else
 4381|    490|    MZ_CLEAR_ARR(r->m_tree_2);
  ------------------
  |  |  761|    490|#define MZ_CLEAR_ARR(obj) memset((obj), 0, sizeof(obj))
  ------------------
 4382|  5.85k|}
zip.c:mz_zip_reader_end_internal:
 6052|  3.74k|                                          mz_bool set_last_error) {
 6053|  3.74k|  mz_bool status = MZ_TRUE;
  ------------------
  |  |  719|  3.74k|#define MZ_TRUE (1)
  ------------------
 6054|       |
 6055|  3.74k|  if (!pZip)
  ------------------
  |  Branch (6055:7): [True: 0, False: 3.74k]
  ------------------
 6056|      0|    return MZ_FALSE;
  ------------------
  |  |  718|      0|#define MZ_FALSE (0)
  ------------------
 6057|       |
 6058|  3.74k|  if ((!pZip->m_pState) || (!pZip->m_pAlloc) || (!pZip->m_pFree) ||
  ------------------
  |  Branch (6058:7): [True: 0, False: 3.74k]
  |  Branch (6058:28): [True: 0, False: 3.74k]
  |  Branch (6058:49): [True: 0, False: 3.74k]
  ------------------
 6059|  3.74k|      (pZip->m_zip_mode != MZ_ZIP_MODE_READING)) {
  ------------------
  |  Branch (6059:7): [True: 0, False: 3.74k]
  ------------------
 6060|      0|    if (set_last_error)
  ------------------
  |  Branch (6060:9): [True: 0, False: 0]
  ------------------
 6061|      0|      pZip->m_last_error = MZ_ZIP_INVALID_PARAMETER;
 6062|       |
 6063|      0|    return MZ_FALSE;
  ------------------
  |  |  718|      0|#define MZ_FALSE (0)
  ------------------
 6064|      0|  }
 6065|       |
 6066|  3.74k|  if (pZip->m_pState) {
  ------------------
  |  Branch (6066:7): [True: 3.74k, False: 0]
  ------------------
 6067|  3.74k|    mz_zip_internal_state *pState = pZip->m_pState;
 6068|  3.74k|    pZip->m_pState = NULL;
 6069|       |
 6070|  3.74k|    mz_zip_array_clear(pZip, &pState->m_central_dir);
 6071|  3.74k|    mz_zip_array_clear(pZip, &pState->m_central_dir_offsets);
 6072|  3.74k|    mz_zip_array_clear(pZip, &pState->m_sorted_central_dir_offsets);
 6073|       |
 6074|  3.74k|#ifndef MINIZ_NO_STDIO
 6075|  3.74k|    if (pState->m_pFile) {
  ------------------
  |  Branch (6075:9): [True: 0, False: 3.74k]
  ------------------
 6076|      0|      if (pZip->m_zip_type == MZ_ZIP_TYPE_FILE) {
  ------------------
  |  Branch (6076:11): [True: 0, False: 0]
  ------------------
 6077|      0|        if (MZ_FCLOSE(pState->m_pFile) == EOF) {
  ------------------
  |  | 5173|      0|#define MZ_FCLOSE fclose
  ------------------
  |  Branch (6077:13): [True: 0, False: 0]
  ------------------
 6078|      0|          if (set_last_error)
  ------------------
  |  Branch (6078:15): [True: 0, False: 0]
  ------------------
 6079|      0|            pZip->m_last_error = MZ_ZIP_FILE_CLOSE_FAILED;
 6080|      0|          status = MZ_FALSE;
  ------------------
  |  |  718|      0|#define MZ_FALSE (0)
  ------------------
 6081|      0|        }
 6082|      0|      }
 6083|      0|      pState->m_pFile = NULL;
 6084|      0|    }
 6085|  3.74k|#endif /* #ifndef MINIZ_NO_STDIO */
 6086|       |
 6087|  3.74k|    pZip->m_pFree(pZip->m_pAlloc_opaque, pState);
 6088|  3.74k|  }
 6089|  3.74k|  pZip->m_zip_mode = MZ_ZIP_MODE_INVALID;
 6090|       |
 6091|  3.74k|  return status;
 6092|  3.74k|}
zip.c:mz_zip_set_error:
 5503|  6.27k|                                               mz_zip_error err_num) {
 5504|  6.27k|  if (pZip)
  ------------------
  |  Branch (5504:7): [True: 6.27k, False: 0]
  ------------------
 5505|  6.27k|    pZip->m_last_error = err_num;
 5506|  6.27k|  return MZ_FALSE;
  ------------------
  |  |  718|  6.27k|#define MZ_FALSE (0)
  ------------------
 5507|  6.27k|}
zip.c:mz_zip_reader_init_internal:
 5510|  3.74k|                                           mz_uint flags) {
 5511|  3.74k|  (void)flags;
 5512|  3.74k|  if ((!pZip) || (pZip->m_pState) || (pZip->m_zip_mode != MZ_ZIP_MODE_INVALID))
  ------------------
  |  Branch (5512:7): [True: 0, False: 3.74k]
  |  Branch (5512:18): [True: 0, False: 3.74k]
  |  Branch (5512:38): [True: 0, False: 3.74k]
  ------------------
 5513|      0|    return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
 5514|       |
 5515|  3.74k|  if (!pZip->m_pAlloc)
  ------------------
  |  Branch (5515:7): [True: 3.74k, False: 0]
  ------------------
 5516|  3.74k|    pZip->m_pAlloc = miniz_def_alloc_func;
 5517|  3.74k|  if (!pZip->m_pFree)
  ------------------
  |  Branch (5517:7): [True: 3.74k, False: 0]
  ------------------
 5518|  3.74k|    pZip->m_pFree = miniz_def_free_func;
 5519|  3.74k|  if (!pZip->m_pRealloc)
  ------------------
  |  Branch (5519:7): [True: 3.74k, False: 0]
  ------------------
 5520|  3.74k|    pZip->m_pRealloc = miniz_def_realloc_func;
 5521|       |
 5522|  3.74k|  pZip->m_archive_size = 0;
 5523|  3.74k|  pZip->m_central_directory_file_ofs = 0;
 5524|  3.74k|  pZip->m_total_files = 0;
 5525|  3.74k|  pZip->m_last_error = MZ_ZIP_NO_ERROR;
 5526|       |
 5527|  3.74k|  if (NULL == (pZip->m_pState = (mz_zip_internal_state *)pZip->m_pAlloc(
  ------------------
  |  Branch (5527:7): [True: 0, False: 3.74k]
  ------------------
 5528|  3.74k|                   pZip->m_pAlloc_opaque, 1, sizeof(mz_zip_internal_state))))
 5529|      0|    return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
 5530|       |
 5531|  3.74k|  memset(pZip->m_pState, 0, sizeof(mz_zip_internal_state));
 5532|  3.74k|  MZ_ZIP_ARRAY_SET_ELEMENT_SIZE(&pZip->m_pState->m_central_dir,
  ------------------
  |  | 5342|  3.74k|  (array_ptr)->m_element_size = element_size
  ------------------
 5533|  3.74k|                                sizeof(mz_uint8));
 5534|  3.74k|  MZ_ZIP_ARRAY_SET_ELEMENT_SIZE(&pZip->m_pState->m_central_dir_offsets,
  ------------------
  |  | 5342|  3.74k|  (array_ptr)->m_element_size = element_size
  ------------------
 5535|  3.74k|                                sizeof(mz_uint32));
 5536|  3.74k|  MZ_ZIP_ARRAY_SET_ELEMENT_SIZE(&pZip->m_pState->m_sorted_central_dir_offsets,
  ------------------
  |  | 5342|  3.74k|  (array_ptr)->m_element_size = element_size
  ------------------
 5537|  3.74k|                                sizeof(mz_uint32));
 5538|  3.74k|  pZip->m_pState->m_init_flags = flags;
 5539|  3.74k|  pZip->m_pState->m_zip64 = MZ_FALSE;
  ------------------
  |  |  718|  3.74k|#define MZ_FALSE (0)
  ------------------
 5540|  3.74k|  pZip->m_pState->m_zip64_has_extended_info_fields = MZ_FALSE;
  ------------------
  |  |  718|  3.74k|#define MZ_FALSE (0)
  ------------------
 5541|       |
 5542|  3.74k|  pZip->m_zip_mode = MZ_ZIP_MODE_READING;
 5543|       |
 5544|  3.74k|  return MZ_TRUE;
  ------------------
  |  |  719|  3.74k|#define MZ_TRUE (1)
  ------------------
 5545|  3.74k|}
zip.c:mz_zip_reader_read_central_dir:
 5705|  3.74k|                                              mz_uint flags) {
 5706|  3.74k|  mz_uint cdir_size = 0, cdir_entries_on_this_disk = 0, num_this_disk = 0,
 5707|  3.74k|          cdir_disk_index = 0;
 5708|  3.74k|  mz_uint64 cdir_ofs = 0, eocd_ofs = 0, archive_ofs = 0;
 5709|  3.74k|  mz_int64 cur_file_ofs = 0;
 5710|  3.74k|  const mz_uint8 *p;
 5711|       |
 5712|  3.74k|  mz_uint32 buf_u32[4096 / sizeof(mz_uint32)];
 5713|  3.74k|  mz_uint8 *pBuf = (mz_uint8 *)buf_u32;
 5714|  3.74k|  mz_bool sort_central_dir =
 5715|  3.74k|      ((flags & MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY) == 0);
 5716|  3.74k|  mz_uint32 zip64_end_of_central_dir_locator_u32
 5717|  3.74k|      [(MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE + sizeof(mz_uint32) - 1) /
 5718|  3.74k|       sizeof(mz_uint32)];
 5719|  3.74k|  mz_uint8 *pZip64_locator = (mz_uint8 *)zip64_end_of_central_dir_locator_u32;
 5720|       |
 5721|  3.74k|  mz_uint32 zip64_end_of_central_dir_header_u32
 5722|  3.74k|      [(MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE + sizeof(mz_uint32) - 1) /
 5723|  3.74k|       sizeof(mz_uint32)];
 5724|  3.74k|  mz_uint8 *pZip64_end_of_central_dir =
 5725|  3.74k|      (mz_uint8 *)zip64_end_of_central_dir_header_u32;
 5726|       |
 5727|  3.74k|  mz_uint64 zip64_end_of_central_dir_ofs = 0;
 5728|       |
 5729|       |  /* Basic sanity checks - reject files which are too small, and check the first
 5730|       |   * 4 bytes of the file to make sure a local header is there. */
 5731|  3.74k|  if (pZip->m_archive_size < MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE)
  ------------------
  |  Branch (5731:7): [True: 0, False: 3.74k]
  ------------------
 5732|      0|    return mz_zip_set_error(pZip, MZ_ZIP_NOT_AN_ARCHIVE);
 5733|       |
 5734|  3.74k|  if (!mz_zip_reader_locate_header_sig(
  ------------------
  |  Branch (5734:7): [True: 57, False: 3.69k]
  ------------------
 5735|  3.74k|          pZip, MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIG,
 5736|  3.74k|          MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE, &cur_file_ofs))
 5737|     57|    return mz_zip_set_error(pZip, MZ_ZIP_FAILED_FINDING_CENTRAL_DIR);
 5738|       |
 5739|  3.69k|  eocd_ofs = cur_file_ofs;
 5740|       |  /* Read and verify the end of central directory record. */
 5741|  3.69k|  if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs, pBuf,
  ------------------
  |  Branch (5741:7): [True: 0, False: 3.69k]
  ------------------
 5742|  3.69k|                    MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE) !=
 5743|  3.69k|      MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE)
 5744|      0|    return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
 5745|       |
 5746|  3.69k|  if (MZ_READ_LE32(pBuf + MZ_ZIP_ECDH_SIG_OFS) !=
  ------------------
  |  |  772|  3.69k|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  773|  3.69k|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) |                           \
  |  |  774|  3.69k|   ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) |                          \
  |  |  775|  3.69k|   ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U))
  ------------------
  |  Branch (5746:7): [True: 0, False: 3.69k]
  ------------------
 5747|  3.69k|      MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIG)
 5748|      0|    return mz_zip_set_error(pZip, MZ_ZIP_NOT_AN_ARCHIVE);
 5749|       |
 5750|  3.69k|  if (cur_file_ofs >= (MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE +
  ------------------
  |  Branch (5750:7): [True: 2.16k, False: 1.53k]
  ------------------
 5751|  3.69k|                       MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE)) {
 5752|  2.16k|    if (pZip->m_pRead(pZip->m_pIO_opaque,
  ------------------
  |  Branch (5752:9): [True: 2.16k, False: 0]
  ------------------
 5753|  2.16k|                      cur_file_ofs - MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE,
 5754|  2.16k|                      pZip64_locator,
 5755|  2.16k|                      MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE) ==
 5756|  2.16k|        MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE) {
 5757|  2.16k|      if (MZ_READ_LE32(pZip64_locator + MZ_ZIP64_ECDL_SIG_OFS) ==
  ------------------
  |  |  772|  2.16k|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  773|  2.16k|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) |                           \
  |  |  774|  2.16k|   ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) |                          \
  |  |  775|  2.16k|   ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U))
  ------------------
  |  Branch (5757:11): [True: 624, False: 1.53k]
  ------------------
 5758|  2.16k|          MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIG) {
 5759|    624|        pZip->m_pState->m_zip64 = MZ_TRUE;
  ------------------
  |  |  719|    624|#define MZ_TRUE (1)
  ------------------
 5760|    624|      }
 5761|  2.16k|    }
 5762|  2.16k|  }
 5763|       |
 5764|  3.69k|  if (pZip->m_pState->m_zip64) {
  ------------------
  |  Branch (5764:7): [True: 624, False: 3.06k]
  ------------------
 5765|       |    /* Try locating the EOCD64 right before the EOCD64 locator. This works even
 5766|       |     * when the effective start of the zip header is not yet known. */
 5767|    624|    if (cur_file_ofs < MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE +
  ------------------
  |  Branch (5767:9): [True: 0, False: 624]
  ------------------
 5768|    624|                           MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE)
 5769|      0|      return mz_zip_set_error(pZip, MZ_ZIP_NOT_AN_ARCHIVE);
 5770|       |
 5771|    624|    zip64_end_of_central_dir_ofs = cur_file_ofs -
 5772|    624|                                   MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE -
 5773|    624|                                   MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE;
 5774|       |
 5775|    624|    if (!mz_zip_reader_eocd64_valid(pZip, zip64_end_of_central_dir_ofs,
  ------------------
  |  Branch (5775:9): [True: 419, False: 205]
  ------------------
 5776|    624|                                    pZip64_end_of_central_dir)) {
 5777|       |      /* That failed, try reading where the locator tells us to. */
 5778|    419|      zip64_end_of_central_dir_ofs = MZ_READ_LE64(
  ------------------
  |  |  779|    419|  (((mz_uint64)MZ_READ_LE32(p)) |                                              \
  |  |  ------------------
  |  |  |  |  772|    419|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  |  |  773|    419|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) |                           \
  |  |  |  |  774|    419|   ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) |                          \
  |  |  |  |  775|    419|   ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U))
  |  |  ------------------
  |  |  780|    419|   (((mz_uint64)MZ_READ_LE32((const mz_uint8 *)(p) + sizeof(mz_uint32)))       \
  |  |  ------------------
  |  |  |  |  772|    419|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  |  |  773|    419|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) |                           \
  |  |  |  |  774|    419|   ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) |                          \
  |  |  |  |  775|    419|   ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U))
  |  |  ------------------
  |  |  781|    419|    << 32U))
  ------------------
 5779|    419|          pZip64_locator + MZ_ZIP64_ECDL_REL_OFS_TO_ZIP64_ECDR_OFS);
 5780|       |
 5781|    419|      if (zip64_end_of_central_dir_ofs >
  ------------------
  |  Branch (5781:11): [True: 108, False: 311]
  ------------------
 5782|    419|          (pZip->m_archive_size - MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE))
 5783|    108|        return mz_zip_set_error(pZip, MZ_ZIP_NOT_AN_ARCHIVE);
 5784|       |
 5785|    311|      if (!mz_zip_reader_eocd64_valid(pZip, zip64_end_of_central_dir_ofs,
  ------------------
  |  Branch (5785:11): [True: 64, False: 247]
  ------------------
 5786|    311|                                      pZip64_end_of_central_dir))
 5787|     64|        return mz_zip_set_error(pZip, MZ_ZIP_NOT_AN_ARCHIVE);
 5788|    311|    }
 5789|    624|  }
 5790|       |
 5791|  3.51k|  pZip->m_total_files = MZ_READ_LE16(pBuf + MZ_ZIP_ECDH_CDIR_TOTAL_ENTRIES_OFS);
  ------------------
  |  |  769|  3.51k|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  770|  3.51k|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U))
  ------------------
 5792|  3.51k|  cdir_entries_on_this_disk =
 5793|  3.51k|      MZ_READ_LE16(pBuf + MZ_ZIP_ECDH_CDIR_NUM_ENTRIES_ON_DISK_OFS);
  ------------------
  |  |  769|  3.51k|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  770|  3.51k|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U))
  ------------------
 5794|  3.51k|  num_this_disk = MZ_READ_LE16(pBuf + MZ_ZIP_ECDH_NUM_THIS_DISK_OFS);
  ------------------
  |  |  769|  3.51k|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  770|  3.51k|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U))
  ------------------
 5795|  3.51k|  cdir_disk_index = MZ_READ_LE16(pBuf + MZ_ZIP_ECDH_NUM_DISK_CDIR_OFS);
  ------------------
  |  |  769|  3.51k|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  770|  3.51k|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U))
  ------------------
 5796|  3.51k|  cdir_size = MZ_READ_LE32(pBuf + MZ_ZIP_ECDH_CDIR_SIZE_OFS);
  ------------------
  |  |  772|  3.51k|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  773|  3.51k|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) |                           \
  |  |  774|  3.51k|   ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) |                          \
  |  |  775|  3.51k|   ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U))
  ------------------
 5797|  3.51k|  cdir_ofs = MZ_READ_LE32(pBuf + MZ_ZIP_ECDH_CDIR_OFS_OFS);
  ------------------
  |  |  772|  3.51k|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  773|  3.51k|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) |                           \
  |  |  774|  3.51k|   ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) |                          \
  |  |  775|  3.51k|   ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U))
  ------------------
 5798|       |
 5799|  3.51k|  if (pZip->m_pState->m_zip64) {
  ------------------
  |  Branch (5799:7): [True: 452, False: 3.06k]
  ------------------
 5800|    452|    mz_uint32 zip64_total_num_of_disks =
 5801|    452|        MZ_READ_LE32(pZip64_locator + MZ_ZIP64_ECDL_TOTAL_NUMBER_OF_DISKS_OFS);
  ------------------
  |  |  772|    452|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  773|    452|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) |                           \
  |  |  774|    452|   ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) |                          \
  |  |  775|    452|   ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U))
  ------------------
 5802|    452|    mz_uint64 zip64_cdir_total_entries = MZ_READ_LE64(
  ------------------
  |  |  779|    452|  (((mz_uint64)MZ_READ_LE32(p)) |                                              \
  |  |  ------------------
  |  |  |  |  772|    452|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  |  |  773|    452|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) |                           \
  |  |  |  |  774|    452|   ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) |                          \
  |  |  |  |  775|    452|   ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U))
  |  |  ------------------
  |  |  780|    452|   (((mz_uint64)MZ_READ_LE32((const mz_uint8 *)(p) + sizeof(mz_uint32)))       \
  |  |  ------------------
  |  |  |  |  772|    452|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  |  |  773|    452|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) |                           \
  |  |  |  |  774|    452|   ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) |                          \
  |  |  |  |  775|    452|   ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U))
  |  |  ------------------
  |  |  781|    452|    << 32U))
  ------------------
 5803|    452|        pZip64_end_of_central_dir + MZ_ZIP64_ECDH_CDIR_TOTAL_ENTRIES_OFS);
 5804|    452|    mz_uint64 zip64_cdir_total_entries_on_this_disk = MZ_READ_LE64(
  ------------------
  |  |  779|    452|  (((mz_uint64)MZ_READ_LE32(p)) |                                              \
  |  |  ------------------
  |  |  |  |  772|    452|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  |  |  773|    452|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) |                           \
  |  |  |  |  774|    452|   ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) |                          \
  |  |  |  |  775|    452|   ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U))
  |  |  ------------------
  |  |  780|    452|   (((mz_uint64)MZ_READ_LE32((const mz_uint8 *)(p) + sizeof(mz_uint32)))       \
  |  |  ------------------
  |  |  |  |  772|    452|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  |  |  773|    452|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) |                           \
  |  |  |  |  774|    452|   ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) |                          \
  |  |  |  |  775|    452|   ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U))
  |  |  ------------------
  |  |  781|    452|    << 32U))
  ------------------
 5805|    452|        pZip64_end_of_central_dir + MZ_ZIP64_ECDH_CDIR_NUM_ENTRIES_ON_DISK_OFS);
 5806|    452|    mz_uint64 zip64_size_of_end_of_central_dir_record = MZ_READ_LE64(
  ------------------
  |  |  779|    452|  (((mz_uint64)MZ_READ_LE32(p)) |                                              \
  |  |  ------------------
  |  |  |  |  772|    452|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  |  |  773|    452|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) |                           \
  |  |  |  |  774|    452|   ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) |                          \
  |  |  |  |  775|    452|   ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U))
  |  |  ------------------
  |  |  780|    452|   (((mz_uint64)MZ_READ_LE32((const mz_uint8 *)(p) + sizeof(mz_uint32)))       \
  |  |  ------------------
  |  |  |  |  772|    452|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  |  |  773|    452|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) |                           \
  |  |  |  |  774|    452|   ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) |                          \
  |  |  |  |  775|    452|   ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U))
  |  |  ------------------
  |  |  781|    452|    << 32U))
  ------------------
 5807|    452|        pZip64_end_of_central_dir + MZ_ZIP64_ECDH_SIZE_OF_RECORD_OFS);
 5808|    452|    mz_uint64 zip64_size_of_central_directory =
 5809|    452|        MZ_READ_LE64(pZip64_end_of_central_dir + MZ_ZIP64_ECDH_CDIR_SIZE_OFS);
  ------------------
  |  |  779|    452|  (((mz_uint64)MZ_READ_LE32(p)) |                                              \
  |  |  ------------------
  |  |  |  |  772|    452|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  |  |  773|    452|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) |                           \
  |  |  |  |  774|    452|   ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) |                          \
  |  |  |  |  775|    452|   ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U))
  |  |  ------------------
  |  |  780|    452|   (((mz_uint64)MZ_READ_LE32((const mz_uint8 *)(p) + sizeof(mz_uint32)))       \
  |  |  ------------------
  |  |  |  |  772|    452|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  |  |  773|    452|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) |                           \
  |  |  |  |  774|    452|   ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) |                          \
  |  |  |  |  775|    452|   ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U))
  |  |  ------------------
  |  |  781|    452|    << 32U))
  ------------------
 5810|       |
 5811|    452|    if (zip64_size_of_end_of_central_dir_record <
  ------------------
  |  Branch (5811:9): [True: 3, False: 449]
  ------------------
 5812|    452|        (MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE - 12))
 5813|      3|      return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
 5814|       |
 5815|    449|    if (zip64_total_num_of_disks != 1U)
  ------------------
  |  Branch (5815:9): [True: 55, False: 394]
  ------------------
 5816|     55|      return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_MULTIDISK);
 5817|       |
 5818|       |    /* Check for miniz's practical limits */
 5819|    394|    if (zip64_cdir_total_entries > MZ_UINT32_MAX)
  ------------------
  |  |  794|    394|#define MZ_UINT32_MAX (0xFFFFFFFFU)
  ------------------
  |  Branch (5819:9): [True: 54, False: 340]
  ------------------
 5820|     54|      return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES);
 5821|       |
 5822|    340|    pZip->m_total_files = (mz_uint32)zip64_cdir_total_entries;
 5823|       |
 5824|    340|    if (zip64_cdir_total_entries_on_this_disk > MZ_UINT32_MAX)
  ------------------
  |  |  794|    340|#define MZ_UINT32_MAX (0xFFFFFFFFU)
  ------------------
  |  Branch (5824:9): [True: 46, False: 294]
  ------------------
 5825|     46|      return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES);
 5826|       |
 5827|    294|    cdir_entries_on_this_disk =
 5828|    294|        (mz_uint32)zip64_cdir_total_entries_on_this_disk;
 5829|       |
 5830|       |    /* Check for miniz's current practical limits (sorry, this should be enough
 5831|       |     * for millions of files) */
 5832|    294|    if (zip64_size_of_central_directory > MZ_UINT32_MAX)
  ------------------
  |  |  794|    294|#define MZ_UINT32_MAX (0xFFFFFFFFU)
  ------------------
  |  Branch (5832:9): [True: 46, False: 248]
  ------------------
 5833|     46|      return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_CDIR_SIZE);
 5834|       |
 5835|    248|    cdir_size = (mz_uint32)zip64_size_of_central_directory;
 5836|       |
 5837|    248|    num_this_disk = MZ_READ_LE32(pZip64_end_of_central_dir +
  ------------------
  |  |  772|    248|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  773|    248|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) |                           \
  |  |  774|    248|   ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) |                          \
  |  |  775|    248|   ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U))
  ------------------
 5838|    248|                                 MZ_ZIP64_ECDH_NUM_THIS_DISK_OFS);
 5839|       |
 5840|    248|    cdir_disk_index = MZ_READ_LE32(pZip64_end_of_central_dir +
  ------------------
  |  |  772|    248|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  773|    248|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) |                           \
  |  |  774|    248|   ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) |                          \
  |  |  775|    248|   ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U))
  ------------------
 5841|    248|                                   MZ_ZIP64_ECDH_NUM_DISK_CDIR_OFS);
 5842|       |
 5843|    248|    cdir_ofs =
 5844|    248|        MZ_READ_LE64(pZip64_end_of_central_dir + MZ_ZIP64_ECDH_CDIR_OFS_OFS);
  ------------------
  |  |  779|    248|  (((mz_uint64)MZ_READ_LE32(p)) |                                              \
  |  |  ------------------
  |  |  |  |  772|    248|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  |  |  773|    248|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) |                           \
  |  |  |  |  774|    248|   ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) |                          \
  |  |  |  |  775|    248|   ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U))
  |  |  ------------------
  |  |  780|    248|   (((mz_uint64)MZ_READ_LE32((const mz_uint8 *)(p) + sizeof(mz_uint32)))       \
  |  |  ------------------
  |  |  |  |  772|    248|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  |  |  773|    248|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) |                           \
  |  |  |  |  774|    248|   ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) |                          \
  |  |  |  |  775|    248|   ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U))
  |  |  ------------------
  |  |  781|    248|    << 32U))
  ------------------
 5845|    248|  }
 5846|       |
 5847|  3.31k|  if (pZip->m_total_files != cdir_entries_on_this_disk)
  ------------------
  |  Branch (5847:7): [True: 65, False: 3.25k]
  ------------------
 5848|     65|    return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_MULTIDISK);
 5849|       |
 5850|  3.25k|  if (((num_this_disk | cdir_disk_index) != 0) &&
  ------------------
  |  Branch (5850:7): [True: 1.16k, False: 2.08k]
  ------------------
 5851|  1.16k|      ((num_this_disk != 1) || (cdir_disk_index != 1)))
  ------------------
  |  Branch (5851:8): [True: 67, False: 1.10k]
  |  Branch (5851:32): [True: 56, False: 1.04k]
  ------------------
 5852|    123|    return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_MULTIDISK);
 5853|       |
 5854|  3.12k|  if (cdir_size <
  ------------------
  |  Branch (5854:7): [True: 44, False: 3.08k]
  ------------------
 5855|  3.12k|      (mz_uint64)pZip->m_total_files * MZ_ZIP_CENTRAL_DIR_HEADER_SIZE)
 5856|     44|    return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
 5857|       |
 5858|  3.08k|  if ((cdir_ofs + (mz_uint64)cdir_size) > pZip->m_archive_size)
  ------------------
  |  Branch (5858:7): [True: 130, False: 2.95k]
  ------------------
 5859|    130|    return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
 5860|       |
 5861|  2.95k|  if (eocd_ofs < cdir_ofs + cdir_size)
  ------------------
  |  Branch (5861:7): [True: 15, False: 2.93k]
  ------------------
 5862|     15|    return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
 5863|       |
 5864|       |  /* The end of central dir follows the central dir, unless the zip file has
 5865|       |   * some trailing data (e.g. it is appended to an executable file). */
 5866|  2.93k|  archive_ofs = eocd_ofs - (cdir_ofs + cdir_size);
 5867|  2.93k|  if (pZip->m_pState->m_zip64) {
  ------------------
  |  Branch (5867:7): [True: 57, False: 2.88k]
  ------------------
 5868|     57|    if (archive_ofs < MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE +
  ------------------
  |  Branch (5868:9): [True: 8, False: 49]
  ------------------
 5869|     57|                          MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE)
 5870|      8|      return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
 5871|       |
 5872|     49|    archive_ofs -= MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE +
 5873|     49|                   MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE;
 5874|     49|  }
 5875|       |
 5876|       |  /* Update the archive start position, but only if not specified. */
 5877|  2.93k|  if ((pZip->m_zip_type == MZ_ZIP_TYPE_FILE ||
  ------------------
  |  Branch (5877:8): [True: 0, False: 2.93k]
  ------------------
 5878|  2.93k|       pZip->m_zip_type == MZ_ZIP_TYPE_CFILE ||
  ------------------
  |  Branch (5878:8): [True: 0, False: 2.93k]
  ------------------
 5879|  2.93k|       pZip->m_zip_type == MZ_ZIP_TYPE_USER) &&
  ------------------
  |  Branch (5879:8): [True: 0, False: 2.93k]
  ------------------
 5880|      0|      pZip->m_pState->m_file_archive_start_ofs == 0) {
  ------------------
  |  Branch (5880:7): [True: 0, False: 0]
  ------------------
 5881|      0|    pZip->m_pState->m_file_archive_start_ofs = archive_ofs;
 5882|      0|    pZip->m_archive_size -= archive_ofs;
 5883|      0|  }
 5884|       |
 5885|  2.93k|  pZip->m_central_directory_file_ofs = cdir_ofs;
 5886|       |
 5887|  2.93k|  if (pZip->m_total_files) {
  ------------------
  |  Branch (5887:7): [True: 2.89k, False: 37]
  ------------------
 5888|  2.89k|    mz_uint i, n;
 5889|       |    /* Read the entire central directory into a heap block, and allocate another
 5890|       |     * heap block to hold the unsorted central dir file record offsets, and
 5891|       |     * possibly another to hold the sorted indices. */
 5892|  2.89k|    if ((!mz_zip_array_resize(pZip, &pZip->m_pState->m_central_dir, cdir_size,
  ------------------
  |  Branch (5892:9): [True: 0, False: 2.89k]
  ------------------
 5893|  2.89k|                              MZ_FALSE)) ||
  ------------------
  |  |  718|  2.89k|#define MZ_FALSE (0)
  ------------------
 5894|  2.89k|        (!mz_zip_array_resize(pZip, &pZip->m_pState->m_central_dir_offsets,
  ------------------
  |  Branch (5894:9): [True: 0, False: 2.89k]
  ------------------
 5895|  2.89k|                              pZip->m_total_files, MZ_FALSE)))
  ------------------
  |  |  718|  2.89k|#define MZ_FALSE (0)
  ------------------
 5896|      0|      return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
 5897|       |
 5898|  2.89k|    if (sort_central_dir) {
  ------------------
  |  Branch (5898:9): [True: 2.89k, False: 0]
  ------------------
 5899|  2.89k|      if (!mz_zip_array_resize(pZip,
  ------------------
  |  Branch (5899:11): [True: 0, False: 2.89k]
  ------------------
 5900|  2.89k|                               &pZip->m_pState->m_sorted_central_dir_offsets,
 5901|  2.89k|                               pZip->m_total_files, MZ_FALSE))
  ------------------
  |  |  718|  2.89k|#define MZ_FALSE (0)
  ------------------
 5902|      0|        return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
 5903|  2.89k|    }
 5904|       |
 5905|  2.89k|    if (pZip->m_pRead(pZip->m_pIO_opaque, cdir_ofs,
  ------------------
  |  Branch (5905:9): [True: 26, False: 2.86k]
  ------------------
 5906|  2.89k|                      pZip->m_pState->m_central_dir.m_p,
 5907|  2.89k|                      cdir_size) != cdir_size)
 5908|     26|      return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
 5909|       |
 5910|       |    /* Now create an index into the central directory file records, do some
 5911|       |     * basic sanity checking on each record */
 5912|  2.86k|    p = (const mz_uint8 *)pZip->m_pState->m_central_dir.m_p;
 5913|  6.78k|    for (n = cdir_size, i = 0; i < pZip->m_total_files; ++i) {
  ------------------
  |  Branch (5913:32): [True: 4.38k, False: 2.39k]
  ------------------
 5914|  4.38k|      mz_uint total_header_size, disk_index, bit_flags, filename_size,
 5915|  4.38k|          ext_data_size;
 5916|  4.38k|      mz_uint64 comp_size, decomp_size, local_header_ofs;
 5917|       |
 5918|  4.38k|      if ((n < MZ_ZIP_CENTRAL_DIR_HEADER_SIZE) ||
  ------------------
  |  Branch (5918:11): [True: 6, False: 4.38k]
  ------------------
 5919|  4.38k|          (MZ_READ_LE32(p) != MZ_ZIP_CENTRAL_DIR_HEADER_SIG))
  ------------------
  |  |  772|  4.38k|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  773|  4.38k|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) |                           \
  |  |  774|  4.38k|   ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) |                          \
  |  |  775|  4.38k|   ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U))
  ------------------
  |  Branch (5919:11): [True: 56, False: 4.32k]
  ------------------
 5920|     62|        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
 5921|       |
 5922|  4.32k|      MZ_ZIP_ARRAY_ELEMENT(&pZip->m_pState->m_central_dir_offsets, mz_uint32,
  ------------------
  |  | 5355|  4.32k|  ((element_type *)((array_ptr)->m_p))[index]
  ------------------
 5923|  4.32k|                           i) =
 5924|  4.32k|          (mz_uint32)(p - (const mz_uint8 *)pZip->m_pState->m_central_dir.m_p);
 5925|       |
 5926|  4.32k|      if (sort_central_dir)
  ------------------
  |  Branch (5926:11): [True: 4.32k, False: 0]
  ------------------
 5927|  4.32k|        MZ_ZIP_ARRAY_ELEMENT(&pZip->m_pState->m_sorted_central_dir_offsets,
  ------------------
  |  | 5355|  4.32k|  ((element_type *)((array_ptr)->m_p))[index]
  ------------------
 5928|  4.32k|                             mz_uint32, i) = i;
 5929|       |
 5930|  4.32k|      comp_size = MZ_READ_LE32(p + MZ_ZIP_CDH_COMPRESSED_SIZE_OFS);
  ------------------
  |  |  772|  4.32k|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  773|  4.32k|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) |                           \
  |  |  774|  4.32k|   ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) |                          \
  |  |  775|  4.32k|   ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U))
  ------------------
 5931|  4.32k|      decomp_size = MZ_READ_LE32(p + MZ_ZIP_CDH_DECOMPRESSED_SIZE_OFS);
  ------------------
  |  |  772|  4.32k|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  773|  4.32k|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) |                           \
  |  |  774|  4.32k|   ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) |                          \
  |  |  775|  4.32k|   ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U))
  ------------------
 5932|  4.32k|      local_header_ofs = MZ_READ_LE32(p + MZ_ZIP_CDH_LOCAL_HEADER_OFS);
  ------------------
  |  |  772|  4.32k|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  773|  4.32k|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) |                           \
  |  |  774|  4.32k|   ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) |                          \
  |  |  775|  4.32k|   ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U))
  ------------------
 5933|  4.32k|      filename_size = MZ_READ_LE16(p + MZ_ZIP_CDH_FILENAME_LEN_OFS);
  ------------------
  |  |  769|  4.32k|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  770|  4.32k|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U))
  ------------------
 5934|  4.32k|      ext_data_size = MZ_READ_LE16(p + MZ_ZIP_CDH_EXTRA_LEN_OFS);
  ------------------
  |  |  769|  4.32k|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  770|  4.32k|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U))
  ------------------
 5935|       |
 5936|  4.32k|      if ((!pZip->m_pState->m_zip64_has_extended_info_fields) &&
  ------------------
  |  Branch (5936:11): [True: 4.12k, False: 204]
  ------------------
 5937|  4.12k|          (ext_data_size) &&
  ------------------
  |  Branch (5937:11): [True: 2.26k, False: 1.85k]
  ------------------
 5938|  2.26k|          (MZ_MAX(MZ_MAX(comp_size, decomp_size), local_header_ofs) ==
  ------------------
  |  |  758|  4.53k|#define MZ_MAX(a, b) (((a) > (b)) ? (a) : (b))
  |  |  ------------------
  |  |  |  Branch (758:23): [True: 1.95k, False: 318]
  |  |  |  Branch (758:25): [True: 1.55k, False: 717]
  |  |  |  Branch (758:38): [True: 1.33k, False: 616]
  |  |  ------------------
  ------------------
  |  Branch (5938:11): [True: 1.44k, False: 827]
  ------------------
 5939|  2.26k|           MZ_UINT32_MAX)) {
  ------------------
  |  |  794|  2.26k|#define MZ_UINT32_MAX (0xFFFFFFFFU)
  ------------------
 5940|       |        /* Attempt to find zip64 extended information field in the entry's extra
 5941|       |         * data */
 5942|  1.44k|        mz_uint32 extra_size_remaining = ext_data_size;
 5943|       |
 5944|  1.44k|        if (extra_size_remaining) {
  ------------------
  |  Branch (5944:13): [True: 1.44k, False: 0]
  ------------------
 5945|  1.44k|          const mz_uint8 *pExtra_data;
 5946|  1.44k|          void *buf = NULL;
 5947|       |
 5948|  1.44k|          if (MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + filename_size + ext_data_size >
  ------------------
  |  Branch (5948:15): [True: 84, False: 1.35k]
  ------------------
 5949|  1.44k|              n) {
 5950|     84|            buf = MZ_MALLOC(ext_data_size);
  ------------------
  |  |  753|     84|#define MZ_MALLOC(x) malloc(x)
  ------------------
 5951|     84|            if (buf == NULL)
  ------------------
  |  Branch (5951:17): [True: 0, False: 84]
  ------------------
 5952|      0|              return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
 5953|       |
 5954|     84|            if (pZip->m_pRead(pZip->m_pIO_opaque,
  ------------------
  |  Branch (5954:17): [True: 40, False: 44]
  ------------------
 5955|     84|                              cdir_ofs + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE +
 5956|     84|                                  filename_size,
 5957|     84|                              buf, ext_data_size) != ext_data_size) {
 5958|     40|              MZ_FREE(buf);
  ------------------
  |  |  754|     40|#define MZ_FREE(x) free(x)
  ------------------
 5959|     40|              return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
 5960|     40|            }
 5961|       |
 5962|     44|            pExtra_data = (mz_uint8 *)buf;
 5963|  1.35k|          } else {
 5964|  1.35k|            pExtra_data = p + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + filename_size;
 5965|  1.35k|          }
 5966|       |
 5967|  6.88k|          do {
 5968|  6.88k|            mz_uint32 field_id;
 5969|  6.88k|            mz_uint32 field_data_size;
 5970|       |
 5971|  6.88k|            if (extra_size_remaining < (sizeof(mz_uint16) * 2)) {
  ------------------
  |  Branch (5971:17): [True: 9, False: 6.88k]
  ------------------
 5972|      9|              MZ_FREE(buf);
  ------------------
  |  |  754|      9|#define MZ_FREE(x) free(x)
  ------------------
 5973|      9|              return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
 5974|      9|            }
 5975|       |
 5976|  6.88k|            field_id = MZ_READ_LE16(pExtra_data);
  ------------------
  |  |  769|  6.88k|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  770|  6.88k|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U))
  ------------------
 5977|  6.88k|            field_data_size = MZ_READ_LE16(pExtra_data + sizeof(mz_uint16));
  ------------------
  |  |  769|  6.88k|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  770|  6.88k|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U))
  ------------------
 5978|       |
 5979|  6.88k|            if ((field_data_size + sizeof(mz_uint16) * 2) >
  ------------------
  |  Branch (5979:17): [True: 52, False: 6.82k]
  ------------------
 5980|  6.88k|                extra_size_remaining) {
 5981|     52|              MZ_FREE(buf);
  ------------------
  |  |  754|     52|#define MZ_FREE(x) free(x)
  ------------------
 5982|     52|              return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
 5983|     52|            }
 5984|       |
 5985|  6.82k|            if (field_id == MZ_ZIP64_EXTENDED_INFORMATION_FIELD_HEADER_ID) {
  ------------------
  |  Branch (5985:17): [True: 562, False: 6.26k]
  ------------------
 5986|       |              /* Ok, the archive didn't have any zip64 headers but it uses a
 5987|       |               * zip64 extended information field so mark it as zip64 anyway
 5988|       |               * (this can occur with infozip's zip util when it reads
 5989|       |               * compresses files from stdin). */
 5990|    562|              pZip->m_pState->m_zip64 = MZ_TRUE;
  ------------------
  |  |  719|    562|#define MZ_TRUE (1)
  ------------------
 5991|    562|              pZip->m_pState->m_zip64_has_extended_info_fields = MZ_TRUE;
  ------------------
  |  |  719|    562|#define MZ_TRUE (1)
  ------------------
 5992|    562|              break;
 5993|    562|            }
 5994|       |
 5995|  6.26k|            pExtra_data += sizeof(mz_uint16) * 2 + field_data_size;
 5996|  6.26k|            extra_size_remaining =
 5997|  6.26k|                extra_size_remaining - sizeof(mz_uint16) * 2 - field_data_size;
 5998|  6.26k|          } while (extra_size_remaining);
  ------------------
  |  Branch (5998:20): [True: 5.48k, False: 778]
  ------------------
 5999|       |
 6000|  1.34k|          MZ_FREE(buf);
  ------------------
  |  |  754|  1.34k|#define MZ_FREE(x) free(x)
  ------------------
 6001|  1.34k|        }
 6002|  1.44k|      }
 6003|       |
 6004|       |      /* I've seen archives that aren't marked as zip64 that uses zip64 ext
 6005|       |       * data, argh */
 6006|  4.22k|      if ((comp_size != MZ_UINT32_MAX) && (decomp_size != MZ_UINT32_MAX)) {
  ------------------
  |  |  794|  4.22k|#define MZ_UINT32_MAX (0xFFFFFFFFU)
  ------------------
                    if ((comp_size != MZ_UINT32_MAX) && (decomp_size != MZ_UINT32_MAX)) {
  ------------------
  |  |  794|  2.03k|#define MZ_UINT32_MAX (0xFFFFFFFFU)
  ------------------
  |  Branch (6006:11): [True: 2.03k, False: 2.18k]
  |  Branch (6006:43): [True: 2.00k, False: 31]
  ------------------
 6007|  2.00k|        if (((!MZ_READ_LE32(p + MZ_ZIP_CDH_METHOD_OFS)) &&
  ------------------
  |  |  772|  2.00k|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  773|  2.00k|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) |                           \
  |  |  774|  2.00k|   ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) |                          \
  |  |  775|  2.00k|   ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U))
  ------------------
  |  Branch (6007:14): [True: 141, False: 1.86k]
  ------------------
 6008|    141|             (decomp_size != comp_size)) ||
  ------------------
  |  Branch (6008:14): [True: 77, False: 64]
  ------------------
 6009|  1.92k|            (decomp_size && !comp_size))
  ------------------
  |  Branch (6009:14): [True: 1.64k, False: 284]
  |  Branch (6009:29): [True: 17, False: 1.62k]
  ------------------
 6010|     94|          return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
 6011|  2.00k|      }
 6012|       |
 6013|  4.12k|      disk_index = MZ_READ_LE16(p + MZ_ZIP_CDH_DISK_START_OFS);
  ------------------
  |  |  769|  4.12k|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  770|  4.12k|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U))
  ------------------
 6014|  4.12k|      if ((disk_index == MZ_UINT16_MAX) ||
  ------------------
  |  |  793|  4.12k|#define MZ_UINT16_MAX (0xFFFFU)
  ------------------
  |  Branch (6014:11): [True: 2, False: 4.12k]
  ------------------
 6015|  4.12k|          ((disk_index != num_this_disk) && (disk_index != 1)))
  ------------------
  |  Branch (6015:12): [True: 282, False: 3.84k]
  |  Branch (6015:45): [True: 88, False: 194]
  ------------------
 6016|     90|        return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_MULTIDISK);
 6017|       |
 6018|  4.03k|      if (comp_size != MZ_UINT32_MAX) {
  ------------------
  |  |  794|  4.03k|#define MZ_UINT32_MAX (0xFFFFFFFFU)
  ------------------
  |  Branch (6018:11): [True: 1.85k, False: 2.18k]
  ------------------
 6019|  1.85k|        if (((mz_uint64)MZ_READ_LE32(p + MZ_ZIP_CDH_LOCAL_HEADER_OFS) +
  ------------------
  |  |  772|  1.85k|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  773|  1.85k|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) |                           \
  |  |  774|  1.85k|   ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) |                          \
  |  |  775|  1.85k|   ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U))
  ------------------
  |  Branch (6019:13): [True: 90, False: 1.76k]
  ------------------
 6020|  1.85k|             MZ_ZIP_LOCAL_DIR_HEADER_SIZE + comp_size) > pZip->m_archive_size)
 6021|     90|          return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
 6022|  1.85k|      }
 6023|       |
 6024|  3.94k|      bit_flags = MZ_READ_LE16(p + MZ_ZIP_CDH_BIT_FLAG_OFS);
  ------------------
  |  |  769|  3.94k|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  770|  3.94k|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U))
  ------------------
 6025|  3.94k|      if (bit_flags & MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_LOCAL_DIR_IS_MASKED)
  ------------------
  |  Branch (6025:11): [True: 3, False: 3.94k]
  ------------------
 6026|      3|        return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_ENCRYPTION);
 6027|       |
 6028|  3.94k|      if ((total_header_size = MZ_ZIP_CENTRAL_DIR_HEADER_SIZE +
  ------------------
  |  Branch (6028:11): [True: 33, False: 3.91k]
  ------------------
 6029|  3.94k|                               MZ_READ_LE16(p + MZ_ZIP_CDH_FILENAME_LEN_OFS) +
  ------------------
  |  |  769|  3.94k|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  770|  3.94k|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U))
  ------------------
 6030|  3.94k|                               MZ_READ_LE16(p + MZ_ZIP_CDH_EXTRA_LEN_OFS) +
  ------------------
  |  |  769|  3.94k|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  770|  3.94k|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U))
  ------------------
 6031|  3.94k|                               MZ_READ_LE16(p + MZ_ZIP_CDH_COMMENT_LEN_OFS)) >
  ------------------
  |  |  769|  3.94k|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  770|  3.94k|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U))
  ------------------
 6032|  3.94k|          n)
 6033|     33|        return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
 6034|       |
 6035|  3.91k|      n -= total_header_size;
 6036|  3.91k|      p += total_header_size;
 6037|  3.91k|    }
 6038|  2.86k|  }
 6039|       |
 6040|  2.43k|  if (sort_central_dir)
  ------------------
  |  Branch (6040:7): [True: 2.43k, False: 0]
  ------------------
 6041|  2.43k|    mz_zip_reader_sort_central_dir_offsets_by_filename(pZip);
 6042|       |
 6043|  2.43k|  return MZ_TRUE;
  ------------------
  |  |  719|  2.43k|#define MZ_TRUE (1)
  ------------------
 6044|  2.93k|}
zip.c:mz_zip_reader_locate_header_sig:
 5645|  3.74k|                                               mz_int64 *pOfs) {
 5646|  3.74k|  mz_int64 cur_file_ofs;
 5647|  3.74k|  mz_uint32 buf_u32[4096 / sizeof(mz_uint32)];
 5648|  3.74k|  mz_uint8 *pBuf = (mz_uint8 *)buf_u32;
 5649|       |
 5650|       |  /* Basic sanity checks - reject files which are too small */
 5651|  3.74k|  if (pZip->m_archive_size < record_size)
  ------------------
  |  Branch (5651:7): [True: 0, False: 3.74k]
  ------------------
 5652|      0|    return MZ_FALSE;
  ------------------
  |  |  718|      0|#define MZ_FALSE (0)
  ------------------
 5653|       |
 5654|       |  /* Find the record by scanning the file from the end towards the beginning. */
 5655|  3.74k|  cur_file_ofs =
 5656|  3.74k|      MZ_MAX((mz_int64)pZip->m_archive_size - (mz_int64)sizeof(buf_u32), 0);
  ------------------
  |  |  758|  3.74k|#define MZ_MAX(a, b) (((a) > (b)) ? (a) : (b))
  |  |  ------------------
  |  |  |  Branch (758:23): [True: 258, False: 3.49k]
  |  |  ------------------
  ------------------
 5657|  3.93k|  for (;;) {
 5658|  3.93k|    int i,
 5659|  3.93k|        n = (int)MZ_MIN(sizeof(buf_u32), pZip->m_archive_size - cur_file_ofs);
  ------------------
  |  |  759|  3.93k|#define MZ_MIN(a, b) (((a) < (b)) ? (a) : (b))
  |  |  ------------------
  |  |  |  Branch (759:23): [True: 188, False: 3.74k]
  |  |  ------------------
  ------------------
 5660|       |
 5661|  3.93k|    if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs, pBuf, n) != (mz_uint)n)
  ------------------
  |  Branch (5661:9): [True: 8, False: 3.92k]
  ------------------
 5662|      8|      return MZ_FALSE;
  ------------------
  |  |  718|      8|#define MZ_FALSE (0)
  ------------------
 5663|       |
 5664|   991k|    for (i = n - 4; i >= 0; --i) {
  ------------------
  |  Branch (5664:21): [True: 991k, False: 237]
  ------------------
 5665|   991k|      mz_uint s = MZ_READ_LE32(pBuf + i);
  ------------------
  |  |  772|   991k|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  773|   991k|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) |                           \
  |  |  774|   991k|   ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) |                          \
  |  |  775|   991k|   ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U))
  ------------------
 5666|   991k|      if (s == record_sig) {
  ------------------
  |  Branch (5666:11): [True: 3.74k, False: 987k]
  ------------------
 5667|  3.74k|        if ((pZip->m_archive_size - (cur_file_ofs + i)) >= record_size)
  ------------------
  |  Branch (5667:13): [True: 3.69k, False: 51]
  ------------------
 5668|  3.69k|          break;
 5669|  3.74k|      }
 5670|   991k|    }
 5671|       |
 5672|  3.92k|    if (i >= 0) {
  ------------------
  |  Branch (5672:9): [True: 3.69k, False: 237]
  ------------------
 5673|  3.69k|      cur_file_ofs += i;
 5674|  3.69k|      break;
 5675|  3.69k|    }
 5676|       |
 5677|       |    /* Give up if we've searched the entire file, or we've gone back "too far"
 5678|       |     * (~64kb) */
 5679|    237|    if ((!cur_file_ofs) || ((pZip->m_archive_size - cur_file_ofs) >=
  ------------------
  |  Branch (5679:9): [True: 46, False: 191]
  |  Branch (5679:28): [True: 3, False: 188]
  ------------------
 5680|    191|                            ((mz_uint64)(MZ_UINT16_MAX) + record_size)))
  ------------------
  |  |  793|    191|#define MZ_UINT16_MAX (0xFFFFU)
  ------------------
 5681|     49|      return MZ_FALSE;
  ------------------
  |  |  718|     49|#define MZ_FALSE (0)
  ------------------
 5682|       |
 5683|    188|    cur_file_ofs = MZ_MAX(cur_file_ofs - (sizeof(buf_u32) - 3), 0);
  ------------------
  |  |  758|    188|#define MZ_MAX(a, b) (((a) > (b)) ? (a) : (b))
  |  |  ------------------
  |  |  |  Branch (758:23): [True: 183, False: 5]
  |  |  ------------------
  ------------------
 5684|    188|  }
 5685|       |
 5686|  3.69k|  *pOfs = cur_file_ofs;
 5687|  3.69k|  return MZ_TRUE;
  ------------------
  |  |  719|  3.69k|#define MZ_TRUE (1)
  ------------------
 5688|  3.74k|}
zip.c:mz_zip_reader_eocd64_valid:
 5691|    935|                                          uint8_t *buf) {
 5692|    935|  if (pZip->m_pRead(pZip->m_pIO_opaque, offset, buf,
  ------------------
  |  Branch (5692:7): [True: 935, False: 0]
  ------------------
 5693|    935|                    MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE) ==
 5694|    935|      MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE) {
 5695|    935|    if (MZ_READ_LE32(buf + MZ_ZIP64_ECDH_SIG_OFS) ==
  ------------------
  |  |  772|    935|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  773|    935|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) |                           \
  |  |  774|    935|   ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) |                          \
  |  |  775|    935|   ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U))
  ------------------
  |  Branch (5695:9): [True: 452, False: 483]
  ------------------
 5696|    935|        MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIG) {
 5697|    452|      return MZ_TRUE;
  ------------------
  |  |  719|    452|#define MZ_TRUE (1)
  ------------------
 5698|    452|    }
 5699|    935|  }
 5700|       |
 5701|    483|  return MZ_FALSE;
  ------------------
  |  |  718|    483|#define MZ_FALSE (0)
  ------------------
 5702|    935|}
zip.c:mz_zip_reader_sort_central_dir_offsets_by_filename:
 5586|  2.43k|mz_zip_reader_sort_central_dir_offsets_by_filename(mz_zip_archive *pZip) {
 5587|  2.43k|  mz_zip_internal_state *pState = pZip->m_pState;
 5588|  2.43k|  const mz_zip_array *pCentral_dir_offsets = &pState->m_central_dir_offsets;
 5589|  2.43k|  const mz_zip_array *pCentral_dir = &pState->m_central_dir;
 5590|  2.43k|  mz_uint32 *pIndices;
 5591|  2.43k|  mz_uint32 start, end;
 5592|  2.43k|  const mz_uint32 size = pZip->m_total_files;
 5593|       |
 5594|  2.43k|  if (size <= 1U)
  ------------------
  |  Branch (5594:7): [True: 1.56k, False: 867]
  ------------------
 5595|  1.56k|    return;
 5596|       |
 5597|    867|  pIndices = &MZ_ZIP_ARRAY_ELEMENT(&pState->m_sorted_central_dir_offsets,
  ------------------
  |  | 5355|    867|  ((element_type *)((array_ptr)->m_p))[index]
  ------------------
 5598|    867|                                   mz_uint32, 0);
 5599|       |
 5600|    867|  start = (size - 2U) >> 1U;
 5601|    867|  for (;;) {
 5602|    867|    mz_uint64 child, root = start;
 5603|  1.22k|    for (;;) {
 5604|  1.22k|      if ((child = (root << 1U) + 1U) >= size)
  ------------------
  |  Branch (5604:11): [True: 359, False: 867]
  ------------------
 5605|    359|        break;
 5606|    867|      child += (((child + 1U) < size) &&
  ------------------
  |  Branch (5606:17): [True: 579, False: 288]
  ------------------
 5607|    579|                (mz_zip_reader_filename_less(pCentral_dir, pCentral_dir_offsets,
  ------------------
  |  Branch (5607:17): [True: 313, False: 266]
  ------------------
 5608|    579|                                             pIndices[child],
 5609|    579|                                             pIndices[child + 1U])));
 5610|    867|      if (!mz_zip_reader_filename_less(pCentral_dir, pCentral_dir_offsets,
  ------------------
  |  Branch (5610:11): [True: 508, False: 359]
  ------------------
 5611|    867|                                       pIndices[root], pIndices[child]))
 5612|    508|        break;
 5613|    359|      MZ_SWAP_UINT32(pIndices[root], pIndices[child]);
  ------------------
  |  | 5575|    359|  do {                                                                         \
  |  | 5576|    359|    mz_uint32 t = a;                                                           \
  |  | 5577|    359|    a = b;                                                                     \
  |  | 5578|    359|    b = t;                                                                     \
  |  | 5579|    359|  }                                                                            \
  |  | 5580|    867|  MZ_MACRO_END
  |  |  ------------------
  |  |  |  |  726|    867|#define MZ_MACRO_END while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (726:29): [Folded, False: 359]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 5614|    359|      root = child;
 5615|    359|    }
 5616|    867|    if (!start)
  ------------------
  |  Branch (5616:9): [True: 867, False: 0]
  ------------------
 5617|    867|      break;
 5618|      0|    start--;
 5619|      0|  }
 5620|       |
 5621|    867|  end = size - 1;
 5622|  2.31k|  while (end > 0) {
  ------------------
  |  Branch (5622:10): [True: 1.44k, False: 867]
  ------------------
 5623|  1.44k|    mz_uint64 child, root = 0;
 5624|  1.44k|    MZ_SWAP_UINT32(pIndices[end], pIndices[0]);
  ------------------
  |  | 5575|  1.44k|  do {                                                                         \
  |  | 5576|  1.44k|    mz_uint32 t = a;                                                           \
  |  | 5577|  1.44k|    a = b;                                                                     \
  |  | 5578|  1.44k|    b = t;                                                                     \
  |  | 5579|  1.44k|  }                                                                            \
  |  | 5580|  1.44k|  MZ_MACRO_END
  |  |  ------------------
  |  |  |  |  726|  1.44k|#define MZ_MACRO_END while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (726:29): [Folded, False: 1.44k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 5625|  1.70k|    for (;;) {
 5626|  1.70k|      if ((child = (root << 1U) + 1U) >= end)
  ------------------
  |  Branch (5626:11): [True: 1.12k, False: 579]
  ------------------
 5627|  1.12k|        break;
 5628|    579|      child +=
 5629|    579|          (((child + 1U) < end) &&
  ------------------
  |  Branch (5629:12): [True: 0, False: 579]
  ------------------
 5630|      0|           mz_zip_reader_filename_less(pCentral_dir, pCentral_dir_offsets,
  ------------------
  |  Branch (5630:12): [True: 0, False: 0]
  ------------------
 5631|      0|                                       pIndices[child], pIndices[child + 1U]));
 5632|    579|      if (!mz_zip_reader_filename_less(pCentral_dir, pCentral_dir_offsets,
  ------------------
  |  Branch (5632:11): [True: 321, False: 258]
  ------------------
 5633|    579|                                       pIndices[root], pIndices[child]))
 5634|    321|        break;
 5635|    258|      MZ_SWAP_UINT32(pIndices[root], pIndices[child]);
  ------------------
  |  | 5575|    258|  do {                                                                         \
  |  | 5576|    258|    mz_uint32 t = a;                                                           \
  |  | 5577|    258|    a = b;                                                                     \
  |  | 5578|    258|    b = t;                                                                     \
  |  | 5579|    258|  }                                                                            \
  |  | 5580|    579|  MZ_MACRO_END
  |  |  ------------------
  |  |  |  |  726|    579|#define MZ_MACRO_END while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (726:29): [Folded, False: 258]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 5636|    258|      root = child;
 5637|    258|    }
 5638|  1.44k|    end--;
 5639|  1.44k|  }
 5640|    867|}
zip.c:mz_zip_reader_filename_less:
 5550|  2.02k|                            mz_uint l_index, mz_uint r_index) {
 5551|  2.02k|  const mz_uint8 *pL = &MZ_ZIP_ARRAY_ELEMENT(
  ------------------
  |  | 5355|  2.02k|  ((element_type *)((array_ptr)->m_p))[index]
  ------------------
 5552|  2.02k|                     pCentral_dir_array, mz_uint8,
 5553|  2.02k|                     MZ_ZIP_ARRAY_ELEMENT(pCentral_dir_offsets, mz_uint32,
 5554|  2.02k|                                          l_index)),
 5555|  2.02k|                 *pE;
 5556|  2.02k|  const mz_uint8 *pR = &MZ_ZIP_ARRAY_ELEMENT(
  ------------------
  |  | 5355|  2.02k|  ((element_type *)((array_ptr)->m_p))[index]
  ------------------
 5557|  2.02k|      pCentral_dir_array, mz_uint8,
 5558|  2.02k|      MZ_ZIP_ARRAY_ELEMENT(pCentral_dir_offsets, mz_uint32, r_index));
 5559|  2.02k|  mz_uint l_len = MZ_READ_LE16(pL + MZ_ZIP_CDH_FILENAME_LEN_OFS),
  ------------------
  |  |  769|  2.02k|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  770|  2.02k|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U))
  ------------------
 5560|  2.02k|          r_len = MZ_READ_LE16(pR + MZ_ZIP_CDH_FILENAME_LEN_OFS);
  ------------------
  |  |  769|  2.02k|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  770|  2.02k|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U))
  ------------------
 5561|  2.02k|  mz_uint8 l = 0, r = 0;
 5562|  2.02k|  pL += MZ_ZIP_CENTRAL_DIR_HEADER_SIZE;
 5563|  2.02k|  pR += MZ_ZIP_CENTRAL_DIR_HEADER_SIZE;
 5564|  2.02k|  pE = pL + MZ_MIN(l_len, r_len);
  ------------------
  |  |  759|  2.02k|#define MZ_MIN(a, b) (((a) < (b)) ? (a) : (b))
  |  |  ------------------
  |  |  |  Branch (759:23): [True: 725, False: 1.30k]
  |  |  ------------------
  ------------------
 5565|  7.05k|  while (pL < pE) {
  ------------------
  |  Branch (5565:10): [True: 6.47k, False: 580]
  ------------------
 5566|  6.47k|    if ((l = MZ_TOLOWER(*pL)) != (r = MZ_TOLOWER(*pR)))
  ------------------
  |  | 5215|  6.47k|#define MZ_TOLOWER(c) ((((c) >= 'A') && ((c) <= 'Z')) ? ((c) - 'A' + 'a') : (c))
  |  |  ------------------
  |  |  |  Branch (5215:25): [True: 4.12k, False: 2.35k]
  |  |  |  Branch (5215:41): [True: 1.00k, False: 3.12k]
  |  |  ------------------
  ------------------
                  if ((l = MZ_TOLOWER(*pL)) != (r = MZ_TOLOWER(*pR)))
  ------------------
  |  | 5215|  6.47k|#define MZ_TOLOWER(c) ((((c) >= 'A') && ((c) <= 'Z')) ? ((c) - 'A' + 'a') : (c))
  |  |  ------------------
  |  |  |  Branch (5215:25): [True: 4.23k, False: 2.23k]
  |  |  |  Branch (5215:41): [True: 1.26k, False: 2.97k]
  |  |  ------------------
  ------------------
  |  Branch (5566:9): [True: 1.44k, False: 5.03k]
  ------------------
 5567|  1.44k|      break;
 5568|  5.03k|    pL++;
 5569|  5.03k|    pR++;
 5570|  5.03k|  }
 5571|  2.02k|  return (pL == pE) ? (l_len < r_len) : (l < r);
  ------------------
  |  Branch (5571:10): [True: 580, False: 1.44k]
  ------------------
 5572|  2.02k|}
zip.c:mz_zip_mem_read_func:
 6117|  15.4k|                                   void *pBuf, size_t n) {
 6118|  15.4k|  mz_zip_archive *pZip = (mz_zip_archive *)pOpaque;
 6119|  15.4k|  size_t s = (file_ofs >= pZip->m_archive_size)
  ------------------
  |  Branch (6119:14): [True: 242, False: 15.1k]
  ------------------
 6120|  15.4k|                 ? 0
 6121|  15.4k|                 : (size_t)MZ_MIN(pZip->m_archive_size - file_ofs, n);
  ------------------
  |  |  759|  15.1k|#define MZ_MIN(a, b) (((a) < (b)) ? (a) : (b))
  |  |  ------------------
  |  |  |  Branch (759:23): [True: 68, False: 15.1k]
  |  |  ------------------
  ------------------
 6122|  15.4k|  memcpy(pBuf, (const mz_uint8 *)pZip->m_pState->m_pMem + file_ofs, s);
 6123|  15.4k|  return s;
 6124|  15.4k|}
zip.c:mz_zip_get_cdh:
 6275|  35.0k|                                                     mz_uint file_index) {
 6276|  35.0k|  if ((!pZip) || (!pZip->m_pState) || (file_index >= pZip->m_total_files))
  ------------------
  |  Branch (6276:7): [True: 0, False: 35.0k]
  |  Branch (6276:18): [True: 0, False: 35.0k]
  |  Branch (6276:39): [True: 0, False: 35.0k]
  ------------------
 6277|      0|    return NULL;
 6278|  35.0k|  return &MZ_ZIP_ARRAY_ELEMENT(
  ------------------
  |  | 5355|  35.0k|  ((element_type *)((array_ptr)->m_p))[index]
  ------------------
 6279|  35.0k|      &pZip->m_pState->m_central_dir, mz_uint8,
 6280|  35.0k|      MZ_ZIP_ARRAY_ELEMENT(&pZip->m_pState->m_central_dir_offsets, mz_uint32,
 6281|  35.0k|                           file_index));
 6282|  35.0k|}
zip.c:mz_zip_string_equal:
 6496|  2.97k|                                                  mz_uint flags) {
 6497|  2.97k|  mz_uint i;
 6498|  2.97k|  if (flags & MZ_ZIP_FLAG_CASE_SENSITIVE)
  ------------------
  |  Branch (6498:7): [True: 2.97k, False: 0]
  ------------------
 6499|  2.97k|    return 0 == memcmp(pA, pB, len);
 6500|      0|  for (i = 0; i < len; ++i)
  ------------------
  |  Branch (6500:15): [True: 0, False: 0]
  ------------------
 6501|      0|    if (MZ_TOLOWER(pA[i]) != MZ_TOLOWER(pB[i]))
  ------------------
  |  | 5215|      0|#define MZ_TOLOWER(c) ((((c) >= 'A') && ((c) <= 'Z')) ? ((c) - 'A' + 'a') : (c))
  |  |  ------------------
  |  |  |  Branch (5215:25): [True: 0, False: 0]
  |  |  |  Branch (5215:41): [True: 0, False: 0]
  |  |  ------------------
  ------------------
                  if (MZ_TOLOWER(pA[i]) != MZ_TOLOWER(pB[i]))
  ------------------
  |  | 5215|      0|#define MZ_TOLOWER(c) ((((c) >= 'A') && ((c) <= 'Z')) ? ((c) - 'A' + 'a') : (c))
  |  |  ------------------
  |  |  |  Branch (5215:25): [True: 0, False: 0]
  |  |  |  Branch (5215:41): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (6501:9): [True: 0, False: 0]
  ------------------
 6502|      0|      return MZ_FALSE;
  ------------------
  |  |  718|      0|#define MZ_FALSE (0)
  ------------------
 6503|      0|  return MZ_TRUE;
  ------------------
  |  |  719|      0|#define MZ_TRUE (1)
  ------------------
 6504|      0|}
zip.c:mz_zip_reader_extract_to_mem_no_alloc1:
 6653|  2.45k|    const mz_zip_archive_file_stat *st) {
 6654|  2.45k|  int status = TINFL_STATUS_DONE;
 6655|  2.45k|  mz_uint64 needed_size, cur_file_ofs, comp_remaining,
 6656|  2.45k|      out_buf_ofs = 0, read_buf_size, read_buf_ofs = 0, read_buf_avail;
 6657|  2.45k|  mz_zip_archive_file_stat file_stat;
 6658|  2.45k|  void *pRead_buf;
 6659|  2.45k|  mz_uint32
 6660|  2.45k|      local_header_u32[(MZ_ZIP_LOCAL_DIR_HEADER_SIZE + sizeof(mz_uint32) - 1) /
 6661|  2.45k|                       sizeof(mz_uint32)];
 6662|  2.45k|  mz_uint8 *pLocal_header = (mz_uint8 *)local_header_u32;
 6663|  2.45k|  tinfl_decompressor inflator;
 6664|       |
 6665|  2.45k|  if ((!pZip) || (!pZip->m_pState) || ((buf_size) && (!pBuf)) ||
  ------------------
  |  Branch (6665:7): [True: 0, False: 2.45k]
  |  Branch (6665:18): [True: 0, False: 2.45k]
  |  Branch (6665:40): [True: 2.30k, False: 149]
  |  Branch (6665:54): [True: 0, False: 2.30k]
  ------------------
 6666|  2.45k|      ((user_read_buf_size) && (!pUser_read_buf)) || (!pZip->m_pRead))
  ------------------
  |  Branch (6666:8): [True: 0, False: 2.45k]
  |  Branch (6666:32): [True: 0, False: 0]
  |  Branch (6666:54): [True: 0, False: 2.45k]
  ------------------
 6667|      0|    return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
 6668|       |
 6669|  2.45k|  if (st) {
  ------------------
  |  Branch (6669:7): [True: 0, False: 2.45k]
  ------------------
 6670|      0|    file_stat = *st;
 6671|  2.45k|  } else if (!mz_zip_reader_file_stat(pZip, file_index, &file_stat))
  ------------------
  |  Branch (6671:14): [True: 0, False: 2.45k]
  ------------------
 6672|      0|    return MZ_FALSE;
  ------------------
  |  |  718|      0|#define MZ_FALSE (0)
  ------------------
 6673|       |
 6674|       |  /* A directory or zero length file */
 6675|  2.45k|  if ((file_stat.m_is_directory) || (!file_stat.m_comp_size))
  ------------------
  |  Branch (6675:7): [True: 574, False: 1.87k]
  |  Branch (6675:37): [True: 51, False: 1.82k]
  ------------------
 6676|    625|    return MZ_TRUE;
  ------------------
  |  |  719|    625|#define MZ_TRUE (1)
  ------------------
 6677|       |
 6678|       |  /* Encryption and patch files are not supported. */
 6679|  1.82k|  if (file_stat.m_bit_flag &
  ------------------
  |  Branch (6679:7): [True: 181, False: 1.64k]
  ------------------
 6680|  1.82k|      (MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_IS_ENCRYPTED |
 6681|  1.82k|       MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_USES_STRONG_ENCRYPTION |
 6682|  1.82k|       MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_COMPRESSED_PATCH_FLAG))
 6683|    181|    return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_ENCRYPTION);
 6684|       |
 6685|       |  /* This function only supports decompressing stored and deflate. */
 6686|  1.64k|  if ((!(flags & MZ_ZIP_FLAG_COMPRESSED_DATA)) && (file_stat.m_method != 0) &&
  ------------------
  |  Branch (6686:7): [True: 1.64k, False: 0]
  |  Branch (6686:51): [True: 1.20k, False: 446]
  ------------------
 6687|  1.20k|      (file_stat.m_method != MZ_DEFLATED))
  ------------------
  |  |  316|  1.20k|#define MZ_DEFLATED 8
  ------------------
  |  Branch (6687:7): [True: 87, False: 1.11k]
  ------------------
 6688|     87|    return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_METHOD);
 6689|       |
 6690|       |  /* Ensure supplied output buffer is large enough. */
 6691|  1.55k|  needed_size = (flags & MZ_ZIP_FLAG_COMPRESSED_DATA) ? file_stat.m_comp_size
  ------------------
  |  Branch (6691:17): [True: 0, False: 1.55k]
  ------------------
 6692|  1.55k|                                                      : file_stat.m_uncomp_size;
 6693|  1.55k|  if (buf_size < needed_size)
  ------------------
  |  Branch (6693:7): [True: 0, False: 1.55k]
  ------------------
 6694|      0|    return mz_zip_set_error(pZip, MZ_ZIP_BUF_TOO_SMALL);
 6695|       |
 6696|       |  /* Read and parse the local directory entry. */
 6697|  1.55k|  cur_file_ofs = file_stat.m_local_header_ofs;
 6698|  1.55k|  if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs, pLocal_header,
  ------------------
  |  Branch (6698:7): [True: 187, False: 1.37k]
  ------------------
 6699|  1.55k|                    MZ_ZIP_LOCAL_DIR_HEADER_SIZE) !=
 6700|  1.55k|      MZ_ZIP_LOCAL_DIR_HEADER_SIZE)
 6701|    187|    return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
 6702|       |
 6703|  1.37k|  if (MZ_READ_LE32(pLocal_header) != MZ_ZIP_LOCAL_DIR_HEADER_SIG)
  ------------------
  |  |  772|  1.37k|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  773|  1.37k|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) |                           \
  |  |  774|  1.37k|   ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) |                          \
  |  |  775|  1.37k|   ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U))
  ------------------
  |  Branch (6703:7): [True: 70, False: 1.30k]
  ------------------
 6704|     70|    return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
 6705|       |
 6706|  1.30k|  cur_file_ofs += (mz_uint64)(MZ_ZIP_LOCAL_DIR_HEADER_SIZE) +
 6707|  1.30k|                  MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_FILENAME_LEN_OFS) +
  ------------------
  |  |  769|  1.30k|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  770|  1.30k|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U))
  ------------------
 6708|  1.30k|                  MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_EXTRA_LEN_OFS);
  ------------------
  |  |  769|  1.30k|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  770|  1.30k|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U))
  ------------------
 6709|  1.30k|  if ((cur_file_ofs + file_stat.m_comp_size) > pZip->m_archive_size)
  ------------------
  |  Branch (6709:7): [True: 102, False: 1.20k]
  ------------------
 6710|    102|    return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
 6711|       |
 6712|  1.20k|  if ((flags & MZ_ZIP_FLAG_COMPRESSED_DATA) || (!file_stat.m_method)) {
  ------------------
  |  Branch (6712:7): [True: 0, False: 1.20k]
  |  Branch (6712:48): [True: 155, False: 1.04k]
  ------------------
 6713|       |    /* The file is stored or the caller has requested the compressed data. */
 6714|    155|    if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs, pBuf,
  ------------------
  |  Branch (6714:9): [True: 49, False: 106]
  ------------------
 6715|    155|                      (size_t)needed_size) != needed_size)
 6716|     49|      return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
 6717|       |
 6718|    106|#ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS
 6719|    106|    if ((flags & MZ_ZIP_FLAG_COMPRESSED_DATA) == 0) {
  ------------------
  |  Branch (6719:9): [True: 106, False: 0]
  ------------------
 6720|    106|      if (mz_crc32(MZ_CRC32_INIT, (const mz_uint8 *)pBuf,
  ------------------
  |  |  300|    106|#define MZ_CRC32_INIT (0)
  ------------------
  |  Branch (6720:11): [True: 100, False: 6]
  ------------------
 6721|    106|                   (size_t)file_stat.m_uncomp_size) != file_stat.m_crc32)
 6722|    100|        return mz_zip_set_error(pZip, MZ_ZIP_CRC_CHECK_FAILED);
 6723|    106|    }
 6724|      6|#endif
 6725|       |
 6726|      6|    return MZ_TRUE;
  ------------------
  |  |  719|      6|#define MZ_TRUE (1)
  ------------------
 6727|    106|  }
 6728|       |
 6729|       |  /* Decompress the file either directly from memory or from a file input
 6730|       |   * buffer. */
 6731|  1.04k|  tinfl_init(&inflator);
  ------------------
  |  | 1191|  1.04k|  do {                                                                         \
  |  | 1192|  1.04k|    (r)->m_state = 0;                                                          \
  |  | 1193|  1.04k|  }                                                                            \
  |  | 1194|  1.20k|  MZ_MACRO_END
  |  |  ------------------
  |  |  |  |  726|  1.20k|#define MZ_MACRO_END while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (726:29): [Folded, False: 1.04k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 6732|       |
 6733|  1.04k|  if (pZip->m_pState->m_pMem) {
  ------------------
  |  Branch (6733:7): [True: 1.04k, False: 0]
  ------------------
 6734|       |    /* Read directly from the archive in memory. */
 6735|  1.04k|    pRead_buf = (mz_uint8 *)pZip->m_pState->m_pMem + cur_file_ofs;
 6736|  1.04k|    read_buf_size = read_buf_avail = file_stat.m_comp_size;
 6737|  1.04k|    comp_remaining = 0;
 6738|  1.04k|  } else if (pUser_read_buf) {
  ------------------
  |  Branch (6738:14): [True: 0, False: 0]
  ------------------
 6739|       |    /* Use a user provided read buffer. */
 6740|      0|    if (!user_read_buf_size)
  ------------------
  |  Branch (6740:9): [True: 0, False: 0]
  ------------------
 6741|      0|      return MZ_FALSE;
  ------------------
  |  |  718|      0|#define MZ_FALSE (0)
  ------------------
 6742|      0|    pRead_buf = (mz_uint8 *)pUser_read_buf;
 6743|      0|    read_buf_size = user_read_buf_size;
 6744|      0|    read_buf_avail = 0;
 6745|      0|    comp_remaining = file_stat.m_comp_size;
 6746|      0|  } else {
 6747|       |    /* Temporarily allocate a read buffer. */
 6748|      0|    read_buf_size =
 6749|      0|        MZ_MIN(file_stat.m_comp_size, (mz_uint64)MZ_ZIP_MAX_IO_BUF_SIZE);
  ------------------
  |  |  759|      0|#define MZ_MIN(a, b) (((a) < (b)) ? (a) : (b))
  |  |  ------------------
  |  |  |  Branch (759:23): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 6750|      0|    if (((sizeof(size_t) == sizeof(mz_uint32))) && (read_buf_size > 0x7FFFFFFF))
  ------------------
  |  Branch (6750:9): [Folded, False: 0]
  |  Branch (6750:52): [True: 0, False: 0]
  ------------------
 6751|      0|      return mz_zip_set_error(pZip, MZ_ZIP_INTERNAL_ERROR);
 6752|       |
 6753|      0|    if (NULL == (pRead_buf = pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1,
  ------------------
  |  Branch (6753:9): [True: 0, False: 0]
  ------------------
 6754|      0|                                            (size_t)read_buf_size)))
 6755|      0|      return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
 6756|       |
 6757|      0|    read_buf_avail = 0;
 6758|      0|    comp_remaining = file_stat.m_comp_size;
 6759|      0|  }
 6760|       |
 6761|  1.04k|  do {
 6762|       |    /* The size_t cast here should be OK because we've verified that the output
 6763|       |     * buffer is >= file_stat.m_uncomp_size above */
 6764|  1.04k|    size_t in_buf_size,
 6765|  1.04k|        out_buf_size = (size_t)(file_stat.m_uncomp_size - out_buf_ofs);
 6766|  1.04k|    if ((!read_buf_avail) && (!pZip->m_pState->m_pMem)) {
  ------------------
  |  Branch (6766:9): [True: 0, False: 1.04k]
  |  Branch (6766:30): [True: 0, False: 0]
  ------------------
 6767|      0|      read_buf_avail = MZ_MIN(read_buf_size, comp_remaining);
  ------------------
  |  |  759|      0|#define MZ_MIN(a, b) (((a) < (b)) ? (a) : (b))
  |  |  ------------------
  |  |  |  Branch (759:23): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 6768|      0|      if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs, pRead_buf,
  ------------------
  |  Branch (6768:11): [True: 0, False: 0]
  ------------------
 6769|      0|                        (size_t)read_buf_avail) != read_buf_avail) {
 6770|      0|        status = TINFL_STATUS_FAILED;
 6771|      0|        mz_zip_set_error(pZip, MZ_ZIP_DECOMPRESSION_FAILED);
 6772|      0|        break;
 6773|      0|      }
 6774|      0|      cur_file_ofs += read_buf_avail;
 6775|      0|      comp_remaining -= read_buf_avail;
 6776|      0|      read_buf_ofs = 0;
 6777|      0|    }
 6778|  1.04k|    in_buf_size = (size_t)read_buf_avail;
 6779|  1.04k|    status = tinfl_decompress(
 6780|  1.04k|        &inflator, (mz_uint8 *)pRead_buf + read_buf_ofs, &in_buf_size,
 6781|  1.04k|        (mz_uint8 *)pBuf, (mz_uint8 *)pBuf + out_buf_ofs, &out_buf_size,
 6782|  1.04k|        TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF |
 6783|  1.04k|            (comp_remaining ? TINFL_FLAG_HAS_MORE_INPUT : 0));
  ------------------
  |  Branch (6783:14): [True: 0, False: 1.04k]
  ------------------
 6784|  1.04k|    read_buf_avail -= in_buf_size;
 6785|  1.04k|    read_buf_ofs += in_buf_size;
 6786|  1.04k|    out_buf_ofs += out_buf_size;
 6787|  1.04k|  } while (status == TINFL_STATUS_NEEDS_MORE_INPUT);
  ------------------
  |  Branch (6787:12): [True: 0, False: 1.04k]
  ------------------
 6788|       |
 6789|  1.04k|  if (status == TINFL_STATUS_DONE) {
  ------------------
  |  Branch (6789:7): [True: 133, False: 912]
  ------------------
 6790|       |    /* Make sure the entire file was decompressed, and check its CRC. */
 6791|    133|    if (out_buf_ofs != file_stat.m_uncomp_size) {
  ------------------
  |  Branch (6791:9): [True: 70, False: 63]
  ------------------
 6792|     70|      mz_zip_set_error(pZip, MZ_ZIP_UNEXPECTED_DECOMPRESSED_SIZE);
 6793|     70|      status = TINFL_STATUS_FAILED;
 6794|     70|    }
 6795|     63|#ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS
 6796|     63|    else if (mz_crc32(MZ_CRC32_INIT, (const mz_uint8 *)pBuf,
  ------------------
  |  |  300|     63|#define MZ_CRC32_INIT (0)
  ------------------
  |  Branch (6796:14): [True: 57, False: 6]
  ------------------
 6797|     63|                      (size_t)file_stat.m_uncomp_size) != file_stat.m_crc32) {
 6798|     57|      mz_zip_set_error(pZip, MZ_ZIP_CRC_CHECK_FAILED);
 6799|     57|      status = TINFL_STATUS_FAILED;
 6800|     57|    }
 6801|    133|#endif
 6802|    133|  }
 6803|       |
 6804|  1.04k|  if ((!pZip->m_pState->m_pMem) && (!pUser_read_buf))
  ------------------
  |  Branch (6804:7): [True: 0, False: 1.04k]
  |  Branch (6804:36): [True: 0, False: 0]
  ------------------
 6805|      0|    pZip->m_pFree(pZip->m_pAlloc_opaque, pRead_buf);
 6806|       |
 6807|  1.04k|  return status == TINFL_STATUS_DONE;
 6808|  1.04k|}
zip.c:mz_zip_file_stat_internal:
 6369|  8.75k|                                         mz_bool *pFound_zip64_extra_data) {
 6370|  8.75k|  mz_uint n;
 6371|  8.75k|  const mz_uint8 *p = pCentral_dir_header;
 6372|       |
 6373|  8.75k|  if (pFound_zip64_extra_data)
  ------------------
  |  Branch (6373:7): [True: 0, False: 8.75k]
  ------------------
 6374|      0|    *pFound_zip64_extra_data = MZ_FALSE;
  ------------------
  |  |  718|      0|#define MZ_FALSE (0)
  ------------------
 6375|       |
 6376|  8.75k|  if ((!p) || (!pStat))
  ------------------
  |  Branch (6376:7): [True: 0, False: 8.75k]
  |  Branch (6376:15): [True: 0, False: 8.75k]
  ------------------
 6377|      0|    return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
 6378|       |
 6379|       |  /* Extract fields from the central directory record. */
 6380|  8.75k|  pStat->m_file_index = file_index;
 6381|  8.75k|  pStat->m_central_dir_ofs = MZ_ZIP_ARRAY_ELEMENT(
  ------------------
  |  | 5355|  8.75k|  ((element_type *)((array_ptr)->m_p))[index]
  ------------------
 6382|  8.75k|      &pZip->m_pState->m_central_dir_offsets, mz_uint32, file_index);
 6383|  8.75k|  pStat->m_version_made_by = MZ_READ_LE16(p + MZ_ZIP_CDH_VERSION_MADE_BY_OFS);
  ------------------
  |  |  769|  8.75k|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  770|  8.75k|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U))
  ------------------
 6384|  8.75k|  pStat->m_version_needed = MZ_READ_LE16(p + MZ_ZIP_CDH_VERSION_NEEDED_OFS);
  ------------------
  |  |  769|  8.75k|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  770|  8.75k|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U))
  ------------------
 6385|  8.75k|  pStat->m_bit_flag = MZ_READ_LE16(p + MZ_ZIP_CDH_BIT_FLAG_OFS);
  ------------------
  |  |  769|  8.75k|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  770|  8.75k|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U))
  ------------------
 6386|  8.75k|  pStat->m_method = MZ_READ_LE16(p + MZ_ZIP_CDH_METHOD_OFS);
  ------------------
  |  |  769|  8.75k|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  770|  8.75k|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U))
  ------------------
 6387|  8.75k|#ifndef MINIZ_NO_TIME
 6388|  8.75k|  pStat->m_time =
 6389|  8.75k|      mz_zip_dos_to_time_t(MZ_READ_LE16(p + MZ_ZIP_CDH_FILE_TIME_OFS),
  ------------------
  |  |  769|  8.75k|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  770|  8.75k|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U))
  ------------------
 6390|  8.75k|                           MZ_READ_LE16(p + MZ_ZIP_CDH_FILE_DATE_OFS));
  ------------------
  |  |  769|  8.75k|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  770|  8.75k|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U))
  ------------------
 6391|  8.75k|#endif
 6392|  8.75k|  pStat->m_crc32 = MZ_READ_LE32(p + MZ_ZIP_CDH_CRC32_OFS);
  ------------------
  |  |  772|  8.75k|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  773|  8.75k|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) |                           \
  |  |  774|  8.75k|   ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) |                          \
  |  |  775|  8.75k|   ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U))
  ------------------
 6393|  8.75k|  pStat->m_comp_size = MZ_READ_LE32(p + MZ_ZIP_CDH_COMPRESSED_SIZE_OFS);
  ------------------
  |  |  772|  8.75k|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  773|  8.75k|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) |                           \
  |  |  774|  8.75k|   ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) |                          \
  |  |  775|  8.75k|   ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U))
  ------------------
 6394|  8.75k|  pStat->m_uncomp_size = MZ_READ_LE32(p + MZ_ZIP_CDH_DECOMPRESSED_SIZE_OFS);
  ------------------
  |  |  772|  8.75k|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  773|  8.75k|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) |                           \
  |  |  774|  8.75k|   ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) |                          \
  |  |  775|  8.75k|   ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U))
  ------------------
 6395|  8.75k|  pStat->m_internal_attr = MZ_READ_LE16(p + MZ_ZIP_CDH_INTERNAL_ATTR_OFS);
  ------------------
  |  |  769|  8.75k|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  770|  8.75k|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U))
  ------------------
 6396|  8.75k|  pStat->m_external_attr = MZ_READ_LE32(p + MZ_ZIP_CDH_EXTERNAL_ATTR_OFS);
  ------------------
  |  |  772|  8.75k|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  773|  8.75k|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) |                           \
  |  |  774|  8.75k|   ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) |                          \
  |  |  775|  8.75k|   ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U))
  ------------------
 6397|  8.75k|  pStat->m_local_header_ofs = MZ_READ_LE32(p + MZ_ZIP_CDH_LOCAL_HEADER_OFS);
  ------------------
  |  |  772|  8.75k|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  773|  8.75k|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) |                           \
  |  |  774|  8.75k|   ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) |                          \
  |  |  775|  8.75k|   ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U))
  ------------------
 6398|       |
 6399|       |  /* Copy as much of the filename and comment as possible. */
 6400|  8.75k|  n = MZ_READ_LE16(p + MZ_ZIP_CDH_FILENAME_LEN_OFS);
  ------------------
  |  |  769|  8.75k|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  770|  8.75k|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U))
  ------------------
 6401|  8.75k|  n = MZ_MIN(n, MZ_ZIP_MAX_ARCHIVE_FILENAME_SIZE - 1);
  ------------------
  |  |  759|  8.75k|#define MZ_MIN(a, b) (((a) < (b)) ? (a) : (b))
  |  |  ------------------
  |  |  |  Branch (759:23): [True: 8.57k, False: 183]
  |  |  ------------------
  ------------------
 6402|  8.75k|  memcpy(pStat->m_filename, p + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE, n);
 6403|  8.75k|  pStat->m_filename[n] = '\0';
 6404|       |
 6405|  8.75k|  n = MZ_READ_LE16(p + MZ_ZIP_CDH_COMMENT_LEN_OFS);
  ------------------
  |  |  769|  8.75k|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  770|  8.75k|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U))
  ------------------
 6406|  8.75k|  n = MZ_MIN(n, MZ_ZIP_MAX_ARCHIVE_FILE_COMMENT_SIZE - 1);
  ------------------
  |  |  759|  8.75k|#define MZ_MIN(a, b) (((a) < (b)) ? (a) : (b))
  |  |  ------------------
  |  |  |  Branch (759:23): [True: 8.73k, False: 21]
  |  |  ------------------
  ------------------
 6407|  8.75k|  pStat->m_comment_size = n;
 6408|  8.75k|  memcpy(pStat->m_comment,
 6409|  8.75k|         p + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE +
 6410|  8.75k|             MZ_READ_LE16(p + MZ_ZIP_CDH_FILENAME_LEN_OFS) +
  ------------------
  |  |  769|  8.75k|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  770|  8.75k|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U))
  ------------------
 6411|  8.75k|             MZ_READ_LE16(p + MZ_ZIP_CDH_EXTRA_LEN_OFS),
  ------------------
  |  |  769|  8.75k|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  770|  8.75k|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U))
  ------------------
 6412|  8.75k|         n);
 6413|  8.75k|  pStat->m_comment[n] = '\0';
 6414|       |
 6415|       |  /* Set some flags for convienance */
 6416|  8.75k|  pStat->m_is_directory = mz_zip_reader_is_file_a_directory(pZip, file_index);
 6417|  8.75k|  pStat->m_is_encrypted = mz_zip_reader_is_file_encrypted(pZip, file_index);
 6418|  8.75k|  pStat->m_is_supported = mz_zip_reader_is_file_supported(pZip, file_index);
 6419|       |
 6420|       |  /* See if we need to read any zip64 extended information fields. */
 6421|       |  /* Confusingly, these zip64 fields can be present even on non-zip64 archives
 6422|       |   * (Debian zip on a huge files from stdin piped to stdout creates them). */
 6423|  8.75k|  if (MZ_MAX(MZ_MAX(pStat->m_comp_size, pStat->m_uncomp_size),
  ------------------
  |  |  758|  17.5k|#define MZ_MAX(a, b) (((a) > (b)) ? (a) : (b))
  |  |  ------------------
  |  |  |  Branch (758:23): [True: 7.23k, False: 1.52k]
  |  |  |  Branch (758:25): [True: 4.53k, False: 4.22k]
  |  |  |  Branch (758:38): [True: 3.82k, False: 3.41k]
  |  |  ------------------
  ------------------
  |  Branch (6423:7): [True: 4.03k, False: 4.72k]
  ------------------
 6424|  8.75k|             pStat->m_local_header_ofs) == MZ_UINT32_MAX) {
  ------------------
  |  |  794|  8.75k|#define MZ_UINT32_MAX (0xFFFFFFFFU)
  ------------------
 6425|       |    /* Attempt to find zip64 extended information field in the entry's extra
 6426|       |     * data */
 6427|  4.03k|    mz_uint32 extra_size_remaining = MZ_READ_LE16(p + MZ_ZIP_CDH_EXTRA_LEN_OFS);
  ------------------
  |  |  769|  4.03k|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  770|  4.03k|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U))
  ------------------
 6428|       |
 6429|  4.03k|    if (extra_size_remaining) {
  ------------------
  |  Branch (6429:9): [True: 2.54k, False: 1.48k]
  ------------------
 6430|  2.54k|      const mz_uint8 *pExtra_data =
 6431|  2.54k|          p + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE +
 6432|  2.54k|          MZ_READ_LE16(p + MZ_ZIP_CDH_FILENAME_LEN_OFS);
  ------------------
  |  |  769|  2.54k|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  770|  2.54k|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U))
  ------------------
 6433|       |
 6434|  5.05k|      do {
 6435|  5.05k|        mz_uint32 field_id;
 6436|  5.05k|        mz_uint32 field_data_size;
 6437|       |
 6438|  5.05k|        if (extra_size_remaining < (sizeof(mz_uint16) * 2))
  ------------------
  |  Branch (6438:13): [True: 11, False: 5.04k]
  ------------------
 6439|     11|          return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
 6440|       |
 6441|  5.04k|        field_id = MZ_READ_LE16(pExtra_data);
  ------------------
  |  |  769|  5.04k|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  770|  5.04k|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U))
  ------------------
 6442|  5.04k|        field_data_size = MZ_READ_LE16(pExtra_data + sizeof(mz_uint16));
  ------------------
  |  |  769|  5.04k|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  770|  5.04k|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U))
  ------------------
 6443|       |
 6444|  5.04k|        if ((field_data_size + sizeof(mz_uint16) * 2) > extra_size_remaining)
  ------------------
  |  Branch (6444:13): [True: 77, False: 4.96k]
  ------------------
 6445|     77|          return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
 6446|       |
 6447|  4.96k|        if (field_id == MZ_ZIP64_EXTENDED_INFORMATION_FIELD_HEADER_ID) {
  ------------------
  |  Branch (6447:13): [True: 1.31k, False: 3.65k]
  ------------------
 6448|  1.31k|          const mz_uint8 *pField_data = pExtra_data + sizeof(mz_uint16) * 2;
 6449|  1.31k|          mz_uint32 field_data_remaining = field_data_size;
 6450|       |
 6451|  1.31k|          if (pFound_zip64_extra_data)
  ------------------
  |  Branch (6451:15): [True: 0, False: 1.31k]
  ------------------
 6452|      0|            *pFound_zip64_extra_data = MZ_TRUE;
  ------------------
  |  |  719|      0|#define MZ_TRUE (1)
  ------------------
 6453|       |
 6454|  1.31k|          if (pStat->m_uncomp_size == MZ_UINT32_MAX) {
  ------------------
  |  |  794|  1.31k|#define MZ_UINT32_MAX (0xFFFFFFFFU)
  ------------------
  |  Branch (6454:15): [True: 73, False: 1.23k]
  ------------------
 6455|     73|            if (field_data_remaining < sizeof(mz_uint64))
  ------------------
  |  Branch (6455:17): [True: 19, False: 54]
  ------------------
 6456|     19|              return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
 6457|       |
 6458|     54|            pStat->m_uncomp_size = MZ_READ_LE64(pField_data);
  ------------------
  |  |  779|     54|  (((mz_uint64)MZ_READ_LE32(p)) |                                              \
  |  |  ------------------
  |  |  |  |  772|     54|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  |  |  773|     54|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) |                           \
  |  |  |  |  774|     54|   ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) |                          \
  |  |  |  |  775|     54|   ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U))
  |  |  ------------------
  |  |  780|     54|   (((mz_uint64)MZ_READ_LE32((const mz_uint8 *)(p) + sizeof(mz_uint32)))       \
  |  |  ------------------
  |  |  |  |  772|     54|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  |  |  773|     54|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) |                           \
  |  |  |  |  774|     54|   ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) |                          \
  |  |  |  |  775|     54|   ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U))
  |  |  ------------------
  |  |  781|     54|    << 32U))
  ------------------
 6459|     54|            pField_data += sizeof(mz_uint64);
 6460|     54|            field_data_remaining -= sizeof(mz_uint64);
 6461|     54|          }
 6462|       |
 6463|  1.29k|          if (pStat->m_comp_size == MZ_UINT32_MAX) {
  ------------------
  |  |  794|  1.29k|#define MZ_UINT32_MAX (0xFFFFFFFFU)
  ------------------
  |  Branch (6463:15): [True: 1.25k, False: 37]
  ------------------
 6464|  1.25k|            if (field_data_remaining < sizeof(mz_uint64))
  ------------------
  |  Branch (6464:17): [True: 150, False: 1.10k]
  ------------------
 6465|    150|              return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
 6466|       |
 6467|  1.10k|            pStat->m_comp_size = MZ_READ_LE64(pField_data);
  ------------------
  |  |  779|  1.10k|  (((mz_uint64)MZ_READ_LE32(p)) |                                              \
  |  |  ------------------
  |  |  |  |  772|  1.10k|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  |  |  773|  1.10k|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) |                           \
  |  |  |  |  774|  1.10k|   ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) |                          \
  |  |  |  |  775|  1.10k|   ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U))
  |  |  ------------------
  |  |  780|  1.10k|   (((mz_uint64)MZ_READ_LE32((const mz_uint8 *)(p) + sizeof(mz_uint32)))       \
  |  |  ------------------
  |  |  |  |  772|  1.10k|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  |  |  773|  1.10k|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) |                           \
  |  |  |  |  774|  1.10k|   ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) |                          \
  |  |  |  |  775|  1.10k|   ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U))
  |  |  ------------------
  |  |  781|  1.10k|    << 32U))
  ------------------
 6468|  1.10k|            pField_data += sizeof(mz_uint64);
 6469|  1.10k|            field_data_remaining -= sizeof(mz_uint64);
 6470|  1.10k|          }
 6471|       |
 6472|  1.14k|          if (pStat->m_local_header_ofs == MZ_UINT32_MAX) {
  ------------------
  |  |  794|  1.14k|#define MZ_UINT32_MAX (0xFFFFFFFFU)
  ------------------
  |  Branch (6472:15): [True: 281, False: 861]
  ------------------
 6473|    281|            if (field_data_remaining < sizeof(mz_uint64))
  ------------------
  |  Branch (6473:17): [True: 11, False: 270]
  ------------------
 6474|     11|              return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
 6475|       |
 6476|    270|            pStat->m_local_header_ofs = MZ_READ_LE64(pField_data);
  ------------------
  |  |  779|    270|  (((mz_uint64)MZ_READ_LE32(p)) |                                              \
  |  |  ------------------
  |  |  |  |  772|    270|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  |  |  773|    270|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) |                           \
  |  |  |  |  774|    270|   ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) |                          \
  |  |  |  |  775|    270|   ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U))
  |  |  ------------------
  |  |  780|    270|   (((mz_uint64)MZ_READ_LE32((const mz_uint8 *)(p) + sizeof(mz_uint32)))       \
  |  |  ------------------
  |  |  |  |  772|    270|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  |  |  773|    270|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) |                           \
  |  |  |  |  774|    270|   ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) |                          \
  |  |  |  |  775|    270|   ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U))
  |  |  ------------------
  |  |  781|    270|    << 32U))
  ------------------
 6477|    270|            pField_data += sizeof(mz_uint64);
 6478|    270|            field_data_remaining -= sizeof(mz_uint64);
 6479|    270|          }
 6480|       |
 6481|  1.13k|          break;
 6482|  1.14k|        }
 6483|       |
 6484|  3.65k|        pExtra_data += sizeof(mz_uint16) * 2 + field_data_size;
 6485|  3.65k|        extra_size_remaining =
 6486|  3.65k|            extra_size_remaining - sizeof(mz_uint16) * 2 - field_data_size;
 6487|  3.65k|      } while (extra_size_remaining);
  ------------------
  |  Branch (6487:16): [True: 2.50k, False: 1.14k]
  ------------------
 6488|  2.54k|    }
 6489|  4.03k|  }
 6490|       |
 6491|  8.49k|  return MZ_TRUE;
  ------------------
  |  |  719|  8.49k|#define MZ_TRUE (1)
  ------------------
 6492|  8.75k|}
zip.c:mz_zip_dos_to_time_t:
 5435|  8.75k|static MZ_TIME_T mz_zip_dos_to_time_t(int dos_time, int dos_date) {
 5436|  8.75k|  struct tm tm;
 5437|  8.75k|  memset(&tm, 0, sizeof(tm));
 5438|  8.75k|  tm.tm_isdst = -1;
 5439|  8.75k|  tm.tm_year = ((dos_date >> 9) & 127) + 1980 - 1900;
 5440|  8.75k|  tm.tm_mon = ((dos_date >> 5) & 15) - 1;
 5441|  8.75k|  tm.tm_mday = dos_date & 31;
 5442|  8.75k|  tm.tm_hour = (dos_time >> 11) & 31;
 5443|  8.75k|  tm.tm_min = (dos_time >> 5) & 63;
 5444|  8.75k|  tm.tm_sec = (dos_time << 1) & 62;
 5445|  8.75k|  return mktime(&tm);
 5446|  8.75k|}
zip.c:mz_zip_array_resize:
 5406|  8.67k|                                                  mz_uint growing) {
 5407|  8.67k|  if (new_size > pArray->m_capacity) {
  ------------------
  |  Branch (5407:7): [True: 8.67k, False: 0]
  ------------------
 5408|  8.67k|    if (!mz_zip_array_ensure_capacity(pZip, pArray, new_size, growing))
  ------------------
  |  Branch (5408:9): [True: 0, False: 8.67k]
  ------------------
 5409|      0|      return MZ_FALSE;
  ------------------
  |  |  718|      0|#define MZ_FALSE (0)
  ------------------
 5410|  8.67k|  }
 5411|  8.67k|  pArray->m_size = new_size;
 5412|  8.67k|  return MZ_TRUE;
  ------------------
  |  |  719|  8.67k|#define MZ_TRUE (1)
  ------------------
 5413|  8.67k|}
zip.c:mz_zip_array_ensure_capacity:
 5373|  8.67k|                                            mz_uint growing) {
 5374|  8.67k|  void *pNew_p;
 5375|  8.67k|  size_t new_capacity = min_new_capacity;
 5376|  8.67k|  MZ_ASSERT(pArray->m_element_size);
  ------------------
  |  |  746|  8.67k|#define MZ_ASSERT(x) assert(x)
  ------------------
 5377|  8.67k|  if (pArray->m_capacity >= min_new_capacity)
  ------------------
  |  Branch (5377:7): [True: 0, False: 8.67k]
  ------------------
 5378|      0|    return MZ_TRUE;
  ------------------
  |  |  719|      0|#define MZ_TRUE (1)
  ------------------
 5379|  8.67k|  if (growing) {
  ------------------
  |  Branch (5379:7): [True: 0, False: 8.67k]
  ------------------
 5380|      0|    new_capacity = MZ_MAX(1, pArray->m_capacity);
  ------------------
  |  |  758|      0|#define MZ_MAX(a, b) (((a) > (b)) ? (a) : (b))
  |  |  ------------------
  |  |  |  Branch (758:23): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 5381|      0|    while (new_capacity < min_new_capacity)
  ------------------
  |  Branch (5381:12): [True: 0, False: 0]
  ------------------
 5382|      0|      new_capacity *= 2;
 5383|      0|  }
 5384|  8.67k|  if (NULL == (pNew_p = pZip->m_pRealloc(pZip->m_pAlloc_opaque, pArray->m_p,
  ------------------
  |  Branch (5384:7): [True: 0, False: 8.67k]
  ------------------
 5385|  8.67k|                                         pArray->m_element_size, new_capacity)))
 5386|      0|    return MZ_FALSE;
  ------------------
  |  |  718|      0|#define MZ_FALSE (0)
  ------------------
 5387|  8.67k|  pArray->m_p = pNew_p;
 5388|  8.67k|  pArray->m_capacity = new_capacity;
 5389|  8.67k|  return MZ_TRUE;
  ------------------
  |  |  719|  8.67k|#define MZ_TRUE (1)
  ------------------
 5390|  8.67k|}
zip.c:mz_zip_array_clear:
 5365|  11.2k|                                              mz_zip_array *pArray) {
 5366|  11.2k|  pZip->m_pFree(pZip->m_pAlloc_opaque, pArray->m_p);
 5367|  11.2k|  memset(pArray, 0, sizeof(mz_zip_array));
 5368|  11.2k|}

zip_close:
 1092|  2.43k|void zip_close(struct zip_t *zip) {
 1093|  2.43k|  if (zip) {
  ------------------
  |  Branch (1093:7): [True: 2.43k, False: 0]
  ------------------
 1094|  2.43k|    mz_zip_archive *pZip = &(zip->archive);
 1095|       |    // Always finalize, even if adding failed for some reason, so we have a
 1096|       |    // valid central directory.
 1097|  2.43k|    if (pZip->m_zip_mode == MZ_ZIP_MODE_WRITING) {
  ------------------
  |  Branch (1097:9): [True: 0, False: 2.43k]
  ------------------
 1098|      0|      mz_zip_writer_finalize_archive(pZip);
 1099|      0|    }
 1100|       |
 1101|  2.43k|    if (pZip->m_zip_mode == MZ_ZIP_MODE_WRITING ||
  ------------------
  |  Branch (1101:9): [True: 0, False: 2.43k]
  ------------------
 1102|  2.43k|        pZip->m_zip_mode == MZ_ZIP_MODE_WRITING_HAS_BEEN_FINALIZED) {
  ------------------
  |  Branch (1102:9): [True: 0, False: 2.43k]
  ------------------
 1103|      0|      zip_archive_truncate(pZip);
 1104|      0|      mz_zip_writer_end(pZip);
 1105|  2.43k|    } else if (pZip->m_zip_mode == MZ_ZIP_MODE_READING) {
  ------------------
  |  Branch (1105:16): [True: 2.43k, False: 0]
  ------------------
 1106|  2.43k|      mz_zip_reader_end(pZip);
 1107|  2.43k|    }
 1108|       |
 1109|       |    CLEANUP(zip);
  ------------------
  |  |   67|  2.43k|  do {                                                                         \
  |  |   68|  2.43k|    if (ptr) {                                                                 \
  |  |  ------------------
  |  |  |  Branch (68:9): [True: 2.43k, False: 0]
  |  |  ------------------
  |  |   69|  2.43k|      free((void *)ptr);                                                       \
  |  |   70|  2.43k|      ptr = NULL;                                                              \
  |  |   71|  2.43k|    }                                                                          \
  |  |   72|  2.43k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (72:12): [Folded, False: 2.43k]
  |  |  ------------------
  ------------------
 1110|  2.43k|  }
 1111|  2.43k|}
zip_entry_opencasesensitive:
 1340|  3.34k|int zip_entry_opencasesensitive(struct zip_t *zip, const char *entryname) {
 1341|  3.34k|  return _zip_entry_open(zip, entryname, 1);
 1342|  3.34k|}
zip_entry_openbyindex:
 1344|  3.84k|int zip_entry_openbyindex(struct zip_t *zip, size_t index) {
 1345|  3.84k|  mz_zip_archive *pZip = NULL;
 1346|  3.84k|  mz_zip_archive_file_stat stats;
 1347|  3.84k|  mz_uint namelen;
 1348|  3.84k|  const mz_uint8 *pHeader;
 1349|  3.84k|  const char *pFilename;
 1350|       |
 1351|  3.84k|  if (!zip) {
  ------------------
  |  Branch (1351:7): [True: 0, False: 3.84k]
  ------------------
 1352|       |    // zip_t handler is not initialized
 1353|      0|    return ZIP_ENOINIT;
  ------------------
  |  |   67|      0|#define ZIP_ENOINIT -1      // not initialized
  ------------------
 1354|      0|  }
 1355|       |
 1356|  3.84k|  pZip = &(zip->archive);
 1357|  3.84k|  if (pZip->m_zip_mode != MZ_ZIP_MODE_READING) {
  ------------------
  |  Branch (1357:7): [True: 0, False: 3.84k]
  ------------------
 1358|       |    // open by index requires readonly mode
 1359|      0|    return ZIP_EINVMODE;
  ------------------
  |  |   70|      0|#define ZIP_EINVMODE -4     // invalid zip mode
  ------------------
 1360|      0|  }
 1361|       |
 1362|  3.84k|  if (index >= (size_t)pZip->m_total_files) {
  ------------------
  |  Branch (1362:7): [True: 0, False: 3.84k]
  ------------------
 1363|       |    // index out of range
 1364|      0|    return ZIP_EINVIDX;
  ------------------
  |  |   76|      0|#define ZIP_EINVIDX -10     // invalid index
  ------------------
 1365|      0|  }
 1366|       |
 1367|  3.84k|  if (!(pHeader = &MZ_ZIP_ARRAY_ELEMENT(
  ------------------
  |  | 5355|  3.84k|  ((element_type *)((array_ptr)->m_p))[index]
  ------------------
  |  Branch (1367:7): [True: 0, False: 3.84k]
  ------------------
 1368|  3.84k|            &pZip->m_pState->m_central_dir, mz_uint8,
 1369|  3.84k|            MZ_ZIP_ARRAY_ELEMENT(&pZip->m_pState->m_central_dir_offsets,
 1370|  3.84k|                                 mz_uint32, (mz_uint)index)))) {
 1371|       |    // cannot find header in central directory
 1372|      0|    return ZIP_ENOHDR;
  ------------------
  |  |   77|      0|#define ZIP_ENOHDR -11      // header not found
  ------------------
 1373|      0|  }
 1374|       |
 1375|  3.84k|  namelen = MZ_READ_LE16(pHeader + MZ_ZIP_CDH_FILENAME_LEN_OFS);
  ------------------
  |  |  769|  3.84k|  ((mz_uint32)(((const mz_uint8 *)(p))[0]) |                                   \
  |  |  770|  3.84k|   ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U))
  ------------------
 1376|  3.84k|  pFilename = (const char *)pHeader + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE;
 1377|       |
 1378|  3.84k|  if (zip->entry.name) {
  ------------------
  |  Branch (1378:7): [True: 0, False: 3.84k]
  ------------------
 1379|      0|    CLEANUP(zip->entry.name);
  ------------------
  |  |   67|      0|  do {                                                                         \
  |  |   68|      0|    if (ptr) {                                                                 \
  |  |  ------------------
  |  |  |  Branch (68:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   69|      0|      free((void *)ptr);                                                       \
  |  |   70|      0|      ptr = NULL;                                                              \
  |  |   71|      0|    }                                                                          \
  |  |   72|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (72:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1380|      0|  }
 1381|       |
 1382|  3.84k|  zip->entry.name = zip_strclone(pFilename, namelen);
 1383|  3.84k|  if (!zip->entry.name) {
  ------------------
  |  Branch (1383:7): [True: 0, False: 3.84k]
  ------------------
 1384|       |    // local entry name is NULL
 1385|      0|    return ZIP_EINVENTNAME;
  ------------------
  |  |   68|      0|#define ZIP_EINVENTNAME -2  // invalid entry name
  ------------------
 1386|      0|  }
 1387|       |
 1388|  3.84k|  if (!mz_zip_reader_file_stat(pZip, (mz_uint)index, &stats)) {
  ------------------
  |  Branch (1388:7): [True: 253, False: 3.58k]
  ------------------
 1389|    253|    return ZIP_ENOENT;
  ------------------
  |  |   69|    253|#define ZIP_ENOENT -3       // entry not found
  ------------------
 1390|    253|  }
 1391|       |
 1392|  3.58k|  zip->entry.index = (ssize_t)index;
 1393|  3.58k|  zip->entry.comp_size = stats.m_comp_size;
 1394|  3.58k|  zip->entry.uncomp_size = stats.m_uncomp_size;
 1395|  3.58k|  zip->entry.uncomp_crc32 = stats.m_crc32;
 1396|  3.58k|  zip->entry.dir_offset = stats.m_central_dir_ofs;
 1397|  3.58k|  zip->entry.header_offset = stats.m_local_header_ofs;
 1398|  3.58k|  zip->entry.method = stats.m_method;
 1399|  3.58k|  zip->entry.external_attr = stats.m_external_attr;
 1400|  3.58k|#ifndef MINIZ_NO_TIME
 1401|  3.58k|  zip->entry.m_time = stats.m_time;
 1402|  3.58k|#endif
 1403|       |
 1404|  3.58k|  return 0;
 1405|  3.84k|}
zip_entry_close:
 1407|  4.47k|int zip_entry_close(struct zip_t *zip) {
 1408|  4.47k|  mz_zip_archive *pzip = NULL;
 1409|  4.47k|  mz_uint level;
 1410|  4.47k|  tdefl_status done;
 1411|  4.47k|  mz_uint16 entrylen;
 1412|  4.47k|  mz_uint16 dos_time = 0, dos_date = 0;
 1413|  4.47k|  int err = 0;
 1414|  4.47k|  mz_uint8 *pExtra_data = NULL;
 1415|  4.47k|  mz_uint32 extra_size = 0;
 1416|  4.47k|  mz_uint8 extra_data[MZ_ZIP64_MAX_CENTRAL_EXTRA_FIELD_SIZE];
 1417|  4.47k|  mz_uint8 local_dir_footer[MZ_ZIP_DATA_DESCRIPTER_SIZE64];
 1418|  4.47k|  mz_uint32 local_dir_footer_size = MZ_ZIP_DATA_DESCRIPTER_SIZE64;
 1419|       |
 1420|  4.47k|  if (!zip) {
  ------------------
  |  Branch (1420:7): [True: 0, False: 4.47k]
  ------------------
 1421|       |    // zip_t handler is not initialized
 1422|      0|    err = ZIP_ENOINIT;
  ------------------
  |  |   67|      0|#define ZIP_ENOINIT -1      // not initialized
  ------------------
 1423|      0|    goto cleanup;
 1424|      0|  }
 1425|       |
 1426|  4.47k|  pzip = &(zip->archive);
 1427|  4.47k|  if (pzip->m_zip_mode == MZ_ZIP_MODE_READING) {
  ------------------
  |  Branch (1427:7): [True: 4.47k, False: 0]
  ------------------
 1428|  4.47k|    goto cleanup;
 1429|  4.47k|  }
 1430|       |
 1431|      0|  level = zip->level & 0xF;
 1432|      0|  if (level) {
  ------------------
  |  Branch (1432:7): [True: 0, False: 0]
  ------------------
 1433|      0|    done = tdefl_compress_buffer(&(zip->entry.comp), "", 0, TDEFL_FINISH);
 1434|      0|    if (done != TDEFL_STATUS_DONE && done != TDEFL_STATUS_OKAY) {
  ------------------
  |  Branch (1434:9): [True: 0, False: 0]
  |  Branch (1434:38): [True: 0, False: 0]
  ------------------
 1435|       |      // Cannot flush compressed buffer
 1436|      0|      err = ZIP_ETDEFLBUF;
  ------------------
  |  |   78|      0|#define ZIP_ETDEFLBUF -12   // cannot flush tdefl buffer
  ------------------
 1437|      0|      goto cleanup;
 1438|      0|    }
 1439|      0|    zip->entry.comp_size = zip->entry.state.m_comp_size;
 1440|      0|    zip->entry.dir_offset = zip->entry.state.m_cur_archive_file_ofs;
 1441|      0|    zip->entry.method = MZ_DEFLATED;
  ------------------
  |  |  316|      0|#define MZ_DEFLATED 8
  ------------------
 1442|      0|  }
 1443|       |
 1444|      0|  entrylen = (mz_uint16)strlen(zip->entry.name);
 1445|      0|#ifndef MINIZ_NO_TIME
 1446|      0|  mz_zip_time_t_to_dos_time(zip->entry.m_time, &dos_time, &dos_date);
 1447|      0|#endif
 1448|       |
 1449|      0|  MZ_WRITE_LE32(local_dir_footer + 0, MZ_ZIP_DATA_DESCRIPTOR_ID);
  ------------------
  |  | 7902|      0|#define MZ_WRITE_LE32(p, v) mz_write_le32((mz_uint8 *)(p), (mz_uint32)(v))
  ------------------
 1450|      0|  MZ_WRITE_LE32(local_dir_footer + 4, zip->entry.uncomp_crc32);
  ------------------
  |  | 7902|      0|#define MZ_WRITE_LE32(p, v) mz_write_le32((mz_uint8 *)(p), (mz_uint32)(v))
  ------------------
 1451|      0|  MZ_WRITE_LE64(local_dir_footer + 8, zip->entry.comp_size);
  ------------------
  |  | 7903|      0|#define MZ_WRITE_LE64(p, v) mz_write_le64((mz_uint8 *)(p), (mz_uint64)(v))
  ------------------
 1452|      0|  MZ_WRITE_LE64(local_dir_footer + 16, zip->entry.uncomp_size);
  ------------------
  |  | 7903|      0|#define MZ_WRITE_LE64(p, v) mz_write_le64((mz_uint8 *)(p), (mz_uint64)(v))
  ------------------
 1453|       |
 1454|      0|  if (pzip->m_pWrite(pzip->m_pIO_opaque, zip->entry.dir_offset,
  ------------------
  |  Branch (1454:7): [True: 0, False: 0]
  ------------------
 1455|      0|                     local_dir_footer,
 1456|      0|                     local_dir_footer_size) != local_dir_footer_size) {
 1457|       |    // Cannot write zip entry header
 1458|      0|    err = ZIP_EWRTHDR;
  ------------------
  |  |   80|      0|#define ZIP_EWRTHDR -14     // cannot write entry header
  ------------------
 1459|      0|    goto cleanup;
 1460|      0|  }
 1461|      0|  zip->entry.dir_offset += local_dir_footer_size;
 1462|       |
 1463|      0|  pExtra_data = extra_data;
 1464|      0|  extra_size = mz_zip_writer_create_zip64_extra_data(
 1465|      0|      extra_data,
 1466|      0|      (zip->entry.uncomp_size >= MZ_UINT32_MAX) ? &zip->entry.uncomp_size
  ------------------
  |  |  794|      0|#define MZ_UINT32_MAX (0xFFFFFFFFU)
  ------------------
  |  Branch (1466:7): [True: 0, False: 0]
  ------------------
 1467|      0|                                                : NULL,
 1468|      0|      (zip->entry.comp_size >= MZ_UINT32_MAX) ? &zip->entry.comp_size : NULL,
  ------------------
  |  |  794|      0|#define MZ_UINT32_MAX (0xFFFFFFFFU)
  ------------------
  |  Branch (1468:7): [True: 0, False: 0]
  ------------------
 1469|      0|      (zip->entry.header_offset >= MZ_UINT32_MAX) ? &zip->entry.header_offset
  ------------------
  |  |  794|      0|#define MZ_UINT32_MAX (0xFFFFFFFFU)
  ------------------
  |  Branch (1469:7): [True: 0, False: 0]
  ------------------
 1470|      0|                                                  : NULL);
 1471|       |
 1472|      0|  if ((entrylen) && ISSLASH(zip->entry.name[entrylen - 1]) &&
  ------------------
  |  |   63|      0|#define ISSLASH(C) ((C) == '/' || (C) == '\\')
  |  |  ------------------
  |  |  |  Branch (63:21): [True: 0, False: 0]
  |  |  |  Branch (63:35): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (1472:7): [True: 0, False: 0]
  ------------------
 1473|      0|      !zip->entry.uncomp_size) {
  ------------------
  |  Branch (1473:7): [True: 0, False: 0]
  ------------------
 1474|       |    /* Set DOS Subdirectory attribute bit. */
 1475|      0|    zip->entry.external_attr |= MZ_ZIP_DOS_DIR_ATTRIBUTE_BITFLAG;
 1476|      0|  }
 1477|       |
 1478|      0|  if (!mz_zip_writer_add_to_central_dir(
  ------------------
  |  Branch (1478:7): [True: 0, False: 0]
  ------------------
 1479|      0|          pzip, zip->entry.name, entrylen, pExtra_data, (mz_uint16)extra_size,
 1480|      0|          "", 0, zip->entry.uncomp_size, zip->entry.comp_size,
 1481|      0|          zip->entry.uncomp_crc32, zip->entry.method,
 1482|      0|          MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_UTF8 |
 1483|      0|              MZ_ZIP_LDH_BIT_FLAG_HAS_LOCATOR,
 1484|      0|          dos_time, dos_date, zip->entry.header_offset,
 1485|      0|          zip->entry.external_attr, NULL, 0)) {
 1486|       |    // Cannot write to zip central dir
 1487|      0|    err = ZIP_EWRTDIR;
  ------------------
  |  |   81|      0|#define ZIP_EWRTDIR -15     // cannot write to central dir
  ------------------
 1488|      0|    goto cleanup;
 1489|      0|  }
 1490|       |
 1491|      0|  pzip->m_total_files++;
 1492|      0|  pzip->m_archive_size = zip->entry.dir_offset;
 1493|       |
 1494|  4.47k|cleanup:
 1495|  4.47k|  if (zip) {
  ------------------
  |  Branch (1495:7): [True: 4.47k, False: 0]
  ------------------
 1496|  4.47k|    zip->entry.m_time = 0;
 1497|  4.47k|    zip->entry.index = -1;
 1498|       |    CLEANUP(zip->entry.name);
  ------------------
  |  |   67|  4.47k|  do {                                                                         \
  |  |   68|  4.47k|    if (ptr) {                                                                 \
  |  |  ------------------
  |  |  |  Branch (68:9): [True: 4.47k, False: 0]
  |  |  ------------------
  |  |   69|  4.47k|      free((void *)ptr);                                                       \
  |  |   70|  4.47k|      ptr = NULL;                                                              \
  |  |   71|  4.47k|    }                                                                          \
  |  |   72|  4.47k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (72:12): [Folded, False: 4.47k]
  |  |  ------------------
  ------------------
 1499|  4.47k|  }
 1500|  4.47k|  return err;
 1501|      0|}
zip_entry_name:
 1503|  3.84k|const char *zip_entry_name(struct zip_t *zip) {
 1504|  3.84k|  if (!zip) {
  ------------------
  |  Branch (1504:7): [True: 0, False: 3.84k]
  ------------------
 1505|       |    // zip_t handler is not initialized
 1506|      0|    return NULL;
 1507|      0|  }
 1508|  3.84k|  return zip->entry.name;
 1509|  3.84k|}
zip_entry_isdir:
 1520|  3.84k|int zip_entry_isdir(struct zip_t *zip) {
 1521|  3.84k|  mz_uint16 entrylen;
 1522|  3.84k|  if (!zip) {
  ------------------
  |  Branch (1522:7): [True: 0, False: 3.84k]
  ------------------
 1523|       |    // zip_t handler is not initialized
 1524|      0|    return ZIP_ENOINIT;
  ------------------
  |  |   67|      0|#define ZIP_ENOINIT -1      // not initialized
  ------------------
 1525|      0|  }
 1526|       |
 1527|  3.84k|  if (zip->entry.index < (ssize_t)0) {
  ------------------
  |  Branch (1527:7): [True: 253, False: 3.58k]
  ------------------
 1528|       |    // zip entry is not opened
 1529|    253|    return ZIP_EINVIDX;
  ------------------
  |  |   76|    253|#define ZIP_EINVIDX -10     // invalid index
  ------------------
 1530|    253|  }
 1531|       |
 1532|  3.58k|  if (!zip->entry.name) {
  ------------------
  |  Branch (1532:7): [True: 0, False: 3.58k]
  ------------------
 1533|      0|    return ZIP_EINVENTNAME;
  ------------------
  |  |   68|      0|#define ZIP_EINVENTNAME -2  // invalid entry name
  ------------------
 1534|      0|  }
 1535|       |
 1536|  3.58k|  entrylen = (mz_uint16)strlen(zip->entry.name);
 1537|  3.58k|  if (entrylen == 0) {
  ------------------
  |  Branch (1537:7): [True: 313, False: 3.27k]
  ------------------
 1538|    313|    return 0;
 1539|    313|  }
 1540|  3.27k|  return ISSLASH(zip->entry.name[entrylen - 1]);
  ------------------
  |  |   63|  3.27k|#define ISSLASH(C) ((C) == '/' || (C) == '\\')
  |  |  ------------------
  |  |  |  Branch (63:21): [True: 50, False: 3.22k]
  |  |  |  Branch (63:35): [True: 191, False: 3.03k]
  |  |  ------------------
  ------------------
 1541|  3.58k|}
zip_entry_size:
 1543|  6.29k|unsigned long long zip_entry_size(struct zip_t *zip) {
 1544|  6.29k|  return zip_entry_uncomp_size(zip);
 1545|  6.29k|}
zip_entry_uncomp_size:
 1547|  6.29k|unsigned long long zip_entry_uncomp_size(struct zip_t *zip) {
 1548|  6.29k|  return zip ? zip->entry.uncomp_size : 0;
  ------------------
  |  Branch (1548:10): [True: 6.29k, False: 0]
  ------------------
 1549|  6.29k|}
zip_entry_comp_size:
 1551|  3.84k|unsigned long long zip_entry_comp_size(struct zip_t *zip) {
 1552|  3.84k|  return zip ? zip->entry.comp_size : 0;
  ------------------
  |  Branch (1552:10): [True: 3.84k, False: 0]
  ------------------
 1553|  3.84k|}
zip_entry_noallocread:
 1702|  2.45k|ssize_t zip_entry_noallocread(struct zip_t *zip, void *buf, size_t bufsize) {
 1703|  2.45k|  mz_zip_archive *pzip = NULL;
 1704|       |
 1705|  2.45k|  if (!zip) {
  ------------------
  |  Branch (1705:7): [True: 0, False: 2.45k]
  ------------------
 1706|       |    // zip_t handler is not initialized
 1707|      0|    return (ssize_t)ZIP_ENOINIT;
  ------------------
  |  |   67|      0|#define ZIP_ENOINIT -1      // not initialized
  ------------------
 1708|      0|  }
 1709|       |
 1710|  2.45k|  pzip = &(zip->archive);
 1711|  2.45k|  if (pzip->m_zip_mode != MZ_ZIP_MODE_READING ||
  ------------------
  |  Branch (1711:7): [True: 0, False: 2.45k]
  ------------------
 1712|  2.45k|      zip->entry.index < (ssize_t)0) {
  ------------------
  |  Branch (1712:7): [True: 0, False: 2.45k]
  ------------------
 1713|       |    // the entry is not found or we do not have read access
 1714|      0|    return (ssize_t)ZIP_ENOENT;
  ------------------
  |  |   69|      0|#define ZIP_ENOENT -3       // entry not found
  ------------------
 1715|      0|  }
 1716|       |
 1717|  2.45k|  if (!mz_zip_reader_extract_to_mem_no_alloc(pzip, (mz_uint)zip->entry.index,
  ------------------
  |  Branch (1717:7): [True: 1.81k, False: 637]
  ------------------
 1718|  2.45k|                                             buf, bufsize, 0, NULL, 0)) {
 1719|  1.81k|    return (ssize_t)ZIP_EMEMNOALLOC;
  ------------------
  |  |   84|  1.81k|#define ZIP_EMEMNOALLOC -18 // extracting data using no memory allocation
  ------------------
 1720|  1.81k|  }
 1721|       |
 1722|    637|  return (ssize_t)zip->entry.uncomp_size;
 1723|  2.45k|}
zip_entries_total:
 1867|  3.75k|ssize_t zip_entries_total(struct zip_t *zip) {
 1868|  3.75k|  if (!zip) {
  ------------------
  |  Branch (1868:7): [True: 1.32k, False: 2.43k]
  ------------------
 1869|       |    // zip_t handler is not initialized
 1870|  1.32k|    return ZIP_ENOINIT;
  ------------------
  |  |   67|  1.32k|#define ZIP_ENOINIT -1      // not initialized
  ------------------
 1871|  1.32k|  }
 1872|       |
 1873|  2.43k|  return (ssize_t)zip->archive.m_total_files;
 1874|  3.75k|}
zip_stream_open:
 1970|  3.75k|                              char mode) {
 1971|  3.75k|  int errnum = 0;
 1972|  3.75k|  return zip_stream_openwitherror(stream, size, level, mode, &errnum);
 1973|  3.75k|}
zip_stream_openwitherror:
 1976|  3.75k|                                       int level, char mode, int *errnum) {
 1977|  3.75k|  mz_uint wflags = (mode == 'w') ? MZ_ZIP_FLAG_WRITE_ZIP64 : 0;
  ------------------
  |  Branch (1977:20): [True: 0, False: 3.75k]
  ------------------
 1978|  3.75k|  struct zip_t *zip = (struct zip_t *)calloc((size_t)1, sizeof(struct zip_t));
 1979|  3.75k|  if (!zip) {
  ------------------
  |  Branch (1979:7): [True: 0, False: 3.75k]
  ------------------
 1980|       |    // out of memory
 1981|      0|    *errnum = ZIP_EOOMEM;
  ------------------
  |  |   87|      0|#define ZIP_EOOMEM -21      // out of memory
  ------------------
 1982|      0|    return NULL;
 1983|      0|  }
 1984|       |
 1985|  3.75k|  zip->entry.index = -1;
 1986|       |
 1987|  3.75k|  if (level < 0) {
  ------------------
  |  Branch (1987:7): [True: 0, False: 3.75k]
  ------------------
 1988|      0|    level = MZ_DEFAULT_LEVEL;
 1989|      0|  }
 1990|  3.75k|  if ((level & 0xF) > MZ_UBER_COMPRESSION) {
  ------------------
  |  Branch (1990:7): [True: 0, False: 3.75k]
  ------------------
 1991|       |    // Wrong compression level
 1992|      0|    *errnum = ZIP_EINVLVL;
  ------------------
  |  |   71|      0|#define ZIP_EINVLVL -5      // invalid compression level
  ------------------
 1993|      0|    goto cleanup;
 1994|      0|  }
 1995|  3.75k|  zip->level = (mz_uint)level;
 1996|       |
 1997|  3.75k|  switch (mode) {
 1998|  3.75k|  case 'r':
  ------------------
  |  Branch (1998:3): [True: 3.75k, False: 0]
  ------------------
 1999|  3.75k|  case ('r' - 64): {
  ------------------
  |  Branch (1999:3): [True: 0, False: 3.75k]
  ------------------
 2000|  3.75k|    if (stream && size > 0) {
  ------------------
  |  Branch (2000:9): [True: 3.75k, False: 0]
  |  Branch (2000:19): [True: 3.75k, False: 0]
  ------------------
 2001|  3.75k|      if (!mz_zip_reader_init_mem(&(zip->archive), stream, size, 0)) {
  ------------------
  |  Branch (2001:11): [True: 1.32k, False: 2.43k]
  ------------------
 2002|  1.32k|        *errnum = ZIP_ERINIT;
  ------------------
  |  |   96|  1.32k|#define ZIP_ERINIT -30      // cannot initialize reader
  ------------------
 2003|  1.32k|        goto cleanup;
 2004|  1.32k|      }
 2005|  3.75k|    } else {
 2006|      0|      *errnum = ZIP_EINVMODE;
  ------------------
  |  |   70|      0|#define ZIP_EINVMODE -4     // invalid zip mode
  ------------------
 2007|      0|      goto cleanup;
 2008|      0|    }
 2009|  3.75k|  } break;
 2010|       |
 2011|  2.43k|  case 'd':
  ------------------
  |  Branch (2011:3): [True: 0, False: 3.75k]
  ------------------
 2012|      0|  case ('d' - 64): {
  ------------------
  |  Branch (2012:3): [True: 0, False: 3.75k]
  ------------------
 2013|      0|    if (stream && size > 0) {
  ------------------
  |  Branch (2013:9): [True: 0, False: 0]
  |  Branch (2013:19): [True: 0, False: 0]
  ------------------
 2014|      0|      if (!mz_zip_reader_init_mem(
  ------------------
  |  Branch (2014:11): [True: 0, False: 0]
  ------------------
 2015|      0|              &(zip->archive), stream, size,
 2016|      0|              zip->level | MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY)) {
 2017|      0|        *errnum = ZIP_ERINIT;
  ------------------
  |  |   96|      0|#define ZIP_ERINIT -30      // cannot initialize reader
  ------------------
 2018|      0|        goto cleanup;
 2019|      0|      }
 2020|      0|      if (!mz_zip_writer_init_from_reader_v2(&(zip->archive), NULL, 0)) {
  ------------------
  |  Branch (2020:11): [True: 0, False: 0]
  ------------------
 2021|      0|        *errnum = ZIP_EWRINIT;
  ------------------
  |  |   98|      0|#define ZIP_EWRINIT -32     // cannot initialize writer from reader
  ------------------
 2022|      0|        mz_zip_reader_end(&(zip->archive));
 2023|      0|        goto cleanup;
 2024|      0|      }
 2025|      0|      zip->archive.m_pWrite = zip_stream_delete_write_func;
 2026|      0|    } else {
 2027|      0|      *errnum = ZIP_EINVMODE;
  ------------------
  |  |   70|      0|#define ZIP_EINVMODE -4     // invalid zip mode
  ------------------
 2028|      0|      goto cleanup;
 2029|      0|    }
 2030|      0|  } break;
 2031|       |
 2032|      0|  case 'w':
  ------------------
  |  Branch (2032:3): [True: 0, False: 3.75k]
  ------------------
 2033|      0|  case ('w' - 64): {
  ------------------
  |  Branch (2033:3): [True: 0, False: 3.75k]
  ------------------
 2034|      0|    if (stream == NULL && size == 0) {
  ------------------
  |  Branch (2034:9): [True: 0, False: 0]
  |  Branch (2034:27): [True: 0, False: 0]
  ------------------
 2035|      0|      if (!mz_zip_writer_init_heap_v2(&(zip->archive), 0, 1024, wflags)) {
  ------------------
  |  Branch (2035:11): [True: 0, False: 0]
  ------------------
 2036|      0|        *errnum = ZIP_EWINIT;
  ------------------
  |  |   97|      0|#define ZIP_EWINIT -31      // cannot initialize writer
  ------------------
 2037|      0|        goto cleanup;
 2038|      0|      }
 2039|      0|    } else {
 2040|      0|      *errnum = ZIP_EINVMODE;
  ------------------
  |  |   70|      0|#define ZIP_EINVMODE -4     // invalid zip mode
  ------------------
 2041|      0|      goto cleanup;
 2042|      0|    }
 2043|      0|  } break;
 2044|       |
 2045|      0|  default:
  ------------------
  |  Branch (2045:3): [True: 0, False: 3.75k]
  ------------------
 2046|      0|    *errnum = ZIP_EINVMODE;
  ------------------
  |  |   70|      0|#define ZIP_EINVMODE -4     // invalid zip mode
  ------------------
 2047|      0|    goto cleanup;
 2048|  3.75k|  }
 2049|       |
 2050|  2.43k|  *errnum = 0;
 2051|  2.43k|  return zip;
 2052|       |
 2053|  1.32k|cleanup:
 2054|  1.32k|  CLEANUP(zip);
  ------------------
  |  |   67|  1.32k|  do {                                                                         \
  |  |   68|  1.32k|    if (ptr) {                                                                 \
  |  |  ------------------
  |  |  |  Branch (68:9): [True: 1.32k, False: 0]
  |  |  ------------------
  |  |   69|  1.32k|      free((void *)ptr);                                                       \
  |  |   70|  1.32k|      ptr = NULL;                                                              \
  |  |   71|  1.32k|    }                                                                          \
  |  |   72|  1.32k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (72:12): [Folded, False: 1.32k]
  |  |  ------------------
  ------------------
 2055|       |  return NULL;
 2056|  3.75k|}
zip.c:_zip_entry_open:
 1133|  3.34k|                           int case_sensitive) {
 1134|  3.34k|  size_t entrylen = 0;
 1135|  3.34k|  mz_zip_archive *pzip = NULL;
 1136|  3.34k|  mz_uint num_alignment_padding_bytes, level;
 1137|  3.34k|  mz_zip_archive_file_stat stats;
 1138|  3.34k|  int err = 0;
 1139|  3.34k|  mz_uint16 dos_time = 0, dos_date = 0;
 1140|  3.34k|  mz_uint32 extra_size = 0;
 1141|  3.34k|  mz_uint8 extra_data[MZ_ZIP64_MAX_CENTRAL_EXTRA_FIELD_SIZE];
 1142|  3.34k|  mz_uint64 local_dir_header_ofs = 0;
 1143|       |
 1144|  3.34k|  if (!zip) {
  ------------------
  |  Branch (1144:7): [True: 0, False: 3.34k]
  ------------------
 1145|      0|    return ZIP_ENOINIT;
  ------------------
  |  |   67|      0|#define ZIP_ENOINIT -1      // not initialized
  ------------------
 1146|      0|  }
 1147|       |
 1148|  3.34k|  local_dir_header_ofs = zip->archive.m_archive_size;
 1149|       |
 1150|  3.34k|  if (!entryname) {
  ------------------
  |  Branch (1150:7): [True: 0, False: 3.34k]
  ------------------
 1151|      0|    return ZIP_EINVENTNAME;
  ------------------
  |  |   68|      0|#define ZIP_EINVENTNAME -2  // invalid entry name
  ------------------
 1152|      0|  }
 1153|       |
 1154|  3.34k|  entrylen = strlen(entryname);
 1155|  3.34k|  if (entrylen == 0) {
  ------------------
  |  Branch (1155:7): [True: 313, False: 3.03k]
  ------------------
 1156|    313|    return ZIP_EINVENTNAME;
  ------------------
  |  |   68|    313|#define ZIP_EINVENTNAME -2  // invalid entry name
  ------------------
 1157|    313|  }
 1158|       |
 1159|  3.03k|  if (zip->entry.name) {
  ------------------
  |  Branch (1159:7): [True: 422, False: 2.61k]
  ------------------
 1160|    422|    CLEANUP(zip->entry.name);
  ------------------
  |  |   67|    422|  do {                                                                         \
  |  |   68|    422|    if (ptr) {                                                                 \
  |  |  ------------------
  |  |  |  Branch (68:9): [True: 422, False: 0]
  |  |  ------------------
  |  |   69|    422|      free((void *)ptr);                                                       \
  |  |   70|    422|      ptr = NULL;                                                              \
  |  |   71|    422|    }                                                                          \
  |  |   72|    422|  } while (0)
  |  |  ------------------
  |  |  |  Branch (72:12): [Folded, False: 422]
  |  |  ------------------
  ------------------
 1161|    422|  }
 1162|       |
 1163|  3.03k|  pzip = &(zip->archive);
 1164|  3.03k|  if (pzip->m_zip_mode == MZ_ZIP_MODE_READING) {
  ------------------
  |  Branch (1164:7): [True: 3.03k, False: 0]
  ------------------
 1165|  3.03k|    zip->entry.name = zip_strclone(entryname, entrylen);
 1166|  3.03k|    if (!zip->entry.name) {
  ------------------
  |  Branch (1166:9): [True: 0, False: 3.03k]
  ------------------
 1167|       |      // Cannot parse zip entry name
 1168|      0|      return ZIP_EINVENTNAME;
  ------------------
  |  |   68|      0|#define ZIP_EINVENTNAME -2  // invalid entry name
  ------------------
 1169|      0|    }
 1170|       |
 1171|  3.03k|    zip->entry.index = (ssize_t)mz_zip_reader_locate_file(
 1172|  3.03k|        pzip, zip->entry.name, NULL,
 1173|  3.03k|        case_sensitive ? MZ_ZIP_FLAG_CASE_SENSITIVE : 0);
  ------------------
  |  Branch (1173:9): [True: 3.03k, False: 0]
  ------------------
 1174|  3.03k|    if (zip->entry.index < (ssize_t)0) {
  ------------------
  |  Branch (1174:9): [True: 565, False: 2.46k]
  ------------------
 1175|    565|      err = ZIP_ENOENT;
  ------------------
  |  |   69|    565|#define ZIP_ENOENT -3       // entry not found
  ------------------
 1176|    565|      goto cleanup;
 1177|    565|    }
 1178|       |
 1179|  2.46k|    if (!mz_zip_reader_file_stat(pzip, (mz_uint)zip->entry.index, &stats)) {
  ------------------
  |  Branch (1179:9): [True: 15, False: 2.45k]
  ------------------
 1180|     15|      err = ZIP_ENOENT;
  ------------------
  |  |   69|     15|#define ZIP_ENOENT -3       // entry not found
  ------------------
 1181|     15|      goto cleanup;
 1182|     15|    }
 1183|       |
 1184|  2.45k|    zip->entry.comp_size = stats.m_comp_size;
 1185|  2.45k|    zip->entry.uncomp_size = stats.m_uncomp_size;
 1186|  2.45k|    zip->entry.uncomp_crc32 = stats.m_crc32;
 1187|  2.45k|    zip->entry.dir_offset = stats.m_central_dir_ofs;
 1188|  2.45k|    zip->entry.header_offset = stats.m_local_header_ofs;
 1189|  2.45k|    zip->entry.method = stats.m_method;
 1190|  2.45k|    zip->entry.external_attr = stats.m_external_attr;
 1191|  2.45k|#ifndef MINIZ_NO_TIME
 1192|  2.45k|    zip->entry.m_time = stats.m_time;
 1193|  2.45k|#endif
 1194|       |
 1195|  2.45k|    return 0;
 1196|  2.46k|  }
 1197|       |
 1198|       |  /*
 1199|       |    .ZIP File Format Specification Version: 6.3.3
 1200|       |
 1201|       |    4.4.17.1 The name of the file, with optional relative path.
 1202|       |    The path stored MUST not contain a drive or
 1203|       |    device letter, or a leading slash.  All slashes
 1204|       |    MUST be forward slashes '/' as opposed to
 1205|       |    backwards slashes '\' for compatibility with Amiga
 1206|       |    and UNIX file systems etc.  If input came from standard
 1207|       |    input, there is no file name field.
 1208|       |  */
 1209|      0|  zip->entry.name = zip_strrpl(entryname, entrylen, '\\', '/');
 1210|      0|  if (!zip->entry.name) {
  ------------------
  |  Branch (1210:7): [True: 0, False: 0]
  ------------------
 1211|       |    // Cannot parse zip entry name
 1212|      0|    return ZIP_EINVENTNAME;
  ------------------
  |  |   68|      0|#define ZIP_EINVENTNAME -2  // invalid entry name
  ------------------
 1213|      0|  }
 1214|       |
 1215|      0|  level = zip->level & 0xF;
 1216|       |
 1217|      0|  zip->entry.index = (ssize_t)zip->archive.m_total_files;
 1218|      0|  zip->entry.comp_size = 0;
 1219|      0|  zip->entry.uncomp_size = 0;
 1220|      0|  zip->entry.uncomp_crc32 = MZ_CRC32_INIT;
  ------------------
  |  |  300|      0|#define MZ_CRC32_INIT (0)
  ------------------
 1221|      0|  zip->entry.dir_offset = zip->archive.m_archive_size;
 1222|      0|  zip->entry.header_offset = zip->archive.m_archive_size;
 1223|      0|  memset(zip->entry.header, 0, MZ_ZIP_LOCAL_DIR_HEADER_SIZE * sizeof(mz_uint8));
 1224|      0|  zip->entry.method = level ? MZ_DEFLATED : 0;
  ------------------
  |  |  316|      0|#define MZ_DEFLATED 8
  ------------------
  |  Branch (1224:23): [True: 0, False: 0]
  ------------------
 1225|       |
 1226|       |  // UNIX or APPLE
 1227|       |#if MZ_PLATFORM == 3 || MZ_PLATFORM == 19
 1228|       |  // regular file with rw-r--r-- permissions
 1229|       |  zip->entry.external_attr = (mz_uint32)(0100644) << 16;
 1230|       |#else
 1231|      0|  zip->entry.external_attr = 0;
 1232|      0|#endif
 1233|       |
 1234|      0|  num_alignment_padding_bytes =
 1235|      0|      mz_zip_writer_compute_padding_needed_for_file_alignment(pzip);
 1236|       |
 1237|      0|  if (!pzip->m_pState || (pzip->m_zip_mode != MZ_ZIP_MODE_WRITING)) {
  ------------------
  |  Branch (1237:7): [True: 0, False: 0]
  |  Branch (1237:26): [True: 0, False: 0]
  ------------------
 1238|       |    // Invalid zip mode
 1239|      0|    err = ZIP_EINVMODE;
  ------------------
  |  |   70|      0|#define ZIP_EINVMODE -4     // invalid zip mode
  ------------------
 1240|      0|    goto cleanup;
 1241|      0|  }
 1242|      0|  if (zip->level & MZ_ZIP_FLAG_COMPRESSED_DATA) {
  ------------------
  |  Branch (1242:7): [True: 0, False: 0]
  ------------------
 1243|       |    // Invalid zip compression level
 1244|      0|    err = ZIP_EINVLVL;
  ------------------
  |  |   71|      0|#define ZIP_EINVLVL -5      // invalid compression level
  ------------------
 1245|      0|    goto cleanup;
 1246|      0|  }
 1247|       |
 1248|      0|  if (!mz_zip_writer_write_zeros(pzip, zip->entry.dir_offset,
  ------------------
  |  Branch (1248:7): [True: 0, False: 0]
  ------------------
 1249|      0|                                 num_alignment_padding_bytes)) {
 1250|       |    // Cannot memset zip entry header
 1251|      0|    err = ZIP_EMEMSET;
  ------------------
  |  |   73|      0|#define ZIP_EMEMSET -7      // memset error
  ------------------
 1252|      0|    goto cleanup;
 1253|      0|  }
 1254|      0|  local_dir_header_ofs += num_alignment_padding_bytes;
 1255|       |
 1256|      0|  zip->entry.m_time = time(NULL);
 1257|      0|#ifndef MINIZ_NO_TIME
 1258|      0|  mz_zip_time_t_to_dos_time(zip->entry.m_time, &dos_time, &dos_date);
 1259|      0|#endif
 1260|       |
 1261|       |  // ZIP64 header with NULL sizes (sizes will be in the data descriptor, just
 1262|       |  // after file data)
 1263|      0|  extra_size = mz_zip_writer_create_zip64_extra_data(
 1264|      0|      extra_data, NULL, NULL,
 1265|      0|      (local_dir_header_ofs >= MZ_UINT32_MAX) ? &local_dir_header_ofs : NULL);
  ------------------
  |  |  794|      0|#define MZ_UINT32_MAX (0xFFFFFFFFU)
  ------------------
  |  Branch (1265:7): [True: 0, False: 0]
  ------------------
 1266|       |
 1267|      0|  if (!mz_zip_writer_create_local_dir_header(
  ------------------
  |  Branch (1267:7): [True: 0, False: 0]
  ------------------
 1268|      0|          pzip, zip->entry.header, (mz_uint16)entrylen, (mz_uint16)extra_size,
 1269|      0|          0, 0, 0, zip->entry.method,
 1270|      0|          MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_UTF8 |
 1271|      0|              MZ_ZIP_LDH_BIT_FLAG_HAS_LOCATOR,
 1272|      0|          dos_time, dos_date)) {
 1273|       |    // Cannot create zip entry header
 1274|      0|    err = ZIP_EMEMSET;
  ------------------
  |  |   73|      0|#define ZIP_EMEMSET -7      // memset error
  ------------------
 1275|      0|    goto cleanup;
 1276|      0|  }
 1277|       |
 1278|      0|  zip->entry.header_offset =
 1279|      0|      zip->entry.dir_offset + num_alignment_padding_bytes;
 1280|       |
 1281|      0|  if (pzip->m_pWrite(pzip->m_pIO_opaque, zip->entry.header_offset,
  ------------------
  |  Branch (1281:7): [True: 0, False: 0]
  ------------------
 1282|      0|                     zip->entry.header,
 1283|      0|                     sizeof(zip->entry.header)) != sizeof(zip->entry.header)) {
 1284|       |    // Cannot write zip entry header
 1285|      0|    err = ZIP_EMEMSET;
  ------------------
  |  |   73|      0|#define ZIP_EMEMSET -7      // memset error
  ------------------
 1286|      0|    goto cleanup;
 1287|      0|  }
 1288|       |
 1289|      0|  if (pzip->m_file_offset_alignment) {
  ------------------
  |  Branch (1289:7): [True: 0, False: 0]
  ------------------
 1290|      0|    MZ_ASSERT(
  ------------------
  |  |  746|      0|#define MZ_ASSERT(x) assert(x)
  ------------------
 1291|      0|        (zip->entry.header_offset & (pzip->m_file_offset_alignment - 1)) == 0);
 1292|      0|  }
 1293|      0|  zip->entry.dir_offset +=
 1294|      0|      num_alignment_padding_bytes + sizeof(zip->entry.header);
 1295|       |
 1296|      0|  if (pzip->m_pWrite(pzip->m_pIO_opaque, zip->entry.dir_offset, zip->entry.name,
  ------------------
  |  Branch (1296:7): [True: 0, False: 0]
  ------------------
 1297|      0|                     entrylen) != entrylen) {
 1298|       |    // Cannot write data to zip entry
 1299|      0|    err = ZIP_EWRTENT;
  ------------------
  |  |   74|      0|#define ZIP_EWRTENT -8      // cannot write data to entry
  ------------------
 1300|      0|    goto cleanup;
 1301|      0|  }
 1302|       |
 1303|      0|  zip->entry.dir_offset += entrylen;
 1304|       |
 1305|      0|  if (pzip->m_pWrite(pzip->m_pIO_opaque, zip->entry.dir_offset, extra_data,
  ------------------
  |  Branch (1305:7): [True: 0, False: 0]
  ------------------
 1306|      0|                     extra_size) != extra_size) {
 1307|       |    // Cannot write ZIP64 data to zip entry
 1308|      0|    err = ZIP_EWRTENT;
  ------------------
  |  |   74|      0|#define ZIP_EWRTENT -8      // cannot write data to entry
  ------------------
 1309|      0|    goto cleanup;
 1310|      0|  }
 1311|      0|  zip->entry.dir_offset += extra_size;
 1312|       |
 1313|      0|  if (level) {
  ------------------
  |  Branch (1313:7): [True: 0, False: 0]
  ------------------
 1314|      0|    zip->entry.state.m_pZip = pzip;
 1315|      0|    zip->entry.state.m_cur_archive_file_ofs = zip->entry.dir_offset;
 1316|      0|    zip->entry.state.m_comp_size = 0;
 1317|       |
 1318|      0|    if (tdefl_init(&(zip->entry.comp), mz_zip_writer_add_put_buf_callback,
  ------------------
  |  Branch (1318:9): [True: 0, False: 0]
  ------------------
 1319|      0|                   &(zip->entry.state),
 1320|      0|                   (int)tdefl_create_comp_flags_from_zip_params(
 1321|      0|                       (int)level, -15, MZ_DEFAULT_STRATEGY)) !=
 1322|      0|        TDEFL_STATUS_OKAY) {
 1323|       |      // Cannot initialize the zip compressor
 1324|      0|      err = ZIP_ETDEFLINIT;
  ------------------
  |  |   75|      0|#define ZIP_ETDEFLINIT -9   // cannot initialize tdefl compressor
  ------------------
 1325|      0|      goto cleanup;
 1326|      0|    }
 1327|      0|  }
 1328|       |
 1329|      0|  return 0;
 1330|       |
 1331|    580|cleanup:
 1332|       |  CLEANUP(zip->entry.name);
  ------------------
  |  |   67|    580|  do {                                                                         \
  |  |   68|    580|    if (ptr) {                                                                 \
  |  |  ------------------
  |  |  |  Branch (68:9): [True: 580, False: 0]
  |  |  ------------------
  |  |   69|    580|      free((void *)ptr);                                                       \
  |  |   70|    580|      ptr = NULL;                                                              \
  |  |   71|    580|    }                                                                          \
  |  |   72|    580|  } while (0)
  |  |  ------------------
  |  |  |  Branch (72:12): [Folded, False: 580]
  |  |  ------------------
  ------------------
 1333|    580|  return err;
 1334|      0|}
zip.c:zip_strclone:
  270|  6.87k|static char *zip_strclone(const char *str, size_t n) {
  271|  6.87k|  char c;
  272|  6.87k|  size_t i;
  273|  6.87k|  char *rpl = (char *)calloc((1 + n), sizeof(char));
  274|  6.87k|  char *begin = rpl;
  275|  6.87k|  if (!rpl) {
  ------------------
  |  Branch (275:7): [True: 0, False: 6.87k]
  ------------------
  276|      0|    return NULL;
  277|      0|  }
  278|       |
  279|  5.67M|  for (i = 0; (i < n) && (c = *str++); ++i) {
  ------------------
  |  Branch (279:15): [True: 5.66M, False: 5.58k]
  |  Branch (279:26): [True: 5.66M, False: 1.28k]
  ------------------
  280|  5.66M|    *rpl++ = c;
  281|  5.66M|  }
  282|       |
  283|  6.87k|  return begin;
  284|  6.87k|}

LLVMFuzzerTestOneInput:
   43|  3.75k|extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
   44|  3.75k|  if (size < 1)
  ------------------
  |  Branch (44:7): [True: 0, False: 3.75k]
  ------------------
   45|      0|    return 0;
   46|       |
   47|  3.75k|  global_init();
   48|       |
   49|  3.75k|  Ogre::String name = "fuzz.zip";
   50|  3.75k|  g_zipFactory->addEmbbeddedFile(name, data, size, nullptr);
   51|       |
   52|  3.75k|  Ogre::Archive *arch = g_zipFactory->createInstance(name, true);
   53|  3.75k|  if (arch) {
  ------------------
  |  Branch (53:7): [True: 3.75k, False: 0]
  ------------------
   54|  3.75k|    try {
   55|  3.75k|      arch->load();
   56|       |      
   57|       |      // List files
   58|  3.75k|      Ogre::StringVectorPtr files = arch->list();
   59|       |      
   60|       |      // Try to open first few files
   61|  3.75k|      int count = 0;
   62|  3.75k|      for (auto &f : *files) {
  ------------------
  |  Branch (62:20): [True: 3.34k, False: 3.75k]
  ------------------
   63|  3.34k|        if (count++ > 10) break;
  ------------------
  |  Branch (63:13): [True: 0, False: 3.34k]
  ------------------
   64|  3.34k|        try {
   65|  3.34k|          Ogre::DataStreamPtr stream = arch->open(f);
   66|  3.34k|          if (stream) {
  ------------------
  |  Branch (66:15): [True: 637, False: 2.70k]
  ------------------
   67|       |            // Read some data
   68|    637|            char buf[1024];
   69|    637|            stream->read(buf, std::min((size_t)1024, (size_t)stream->size()));
   70|    637|          }
   71|  3.34k|        } catch (...) {}
   72|  3.34k|      }
   73|       |      
   74|  3.75k|      arch->unload();
   75|  3.75k|    } catch (...) {}
   76|  3.75k|    g_zipFactory->destroyInstance(arch);
   77|  3.75k|  }
   78|       |
   79|  3.75k|  return 0;
   80|  3.75k|}
zip_fuzz.cpp:_ZL11global_initv:
   26|  3.75k|static void global_init() {
   27|  3.75k|  if (g_initialized)
  ------------------
  |  Branch (27:7): [True: 3.75k, False: 1]
  ------------------
   28|  3.75k|    return;
   29|       |
   30|      1|  auto *logMgr = new Ogre::LogManager();
   31|      1|  logMgr->createLog("fuzz_zip.log", true, false, true);
   32|      1|  logMgr->setMinLogLevel(Ogre::LML_CRITICAL);
   33|       |
   34|      1|  new Ogre::ResourceGroupManager();
   35|      1|  new Ogre::ArchiveManager();
   36|       |  
   37|      1|  g_zipFactory = new Ogre::EmbeddedZipArchiveFactory();
   38|      1|  Ogre::ArchiveManager::getSingleton().addArchiveFactory(g_zipFactory);
   39|       |
   40|      1|  g_initialized = true;
   41|      1|}