_ZNK4pcpp13EnumClassHashINS_17LdapOperationType5ValueELb0EEclES2_:
  123|     44|		{
  124|     44|			return static_cast<std::underlying_type_t<EnumClass>>(value);
  125|     44|		}
_ZNK4pcpp13EnumClassHashINS_14LdapResultCode5ValueELb0EEclES2_:
  123|     78|		{
  124|     78|			return static_cast<std::underlying_type_t<EnumClass>>(value);
  125|     78|		}
_ZNK4pcpp13EnumClassHashINS_22LdapSearchRequestLayer18SearchRequestScope5ValueELb0EEclES3_:
  123|      8|		{
  124|      8|			return static_cast<std::underlying_type_t<EnumClass>>(value);
  125|      8|		}
_ZNK4pcpp13EnumClassHashINS_22LdapSearchRequestLayer12DerefAliases5ValueELb0EEclES3_:
  123|     10|		{
  124|     10|			return static_cast<std::underlying_type_t<EnumClass>>(value);
  125|     10|		}
_ZNK4pcpp13EnumClassHashINS_12Asn1TagClassELb0EEclES1_:
  123|      8|		{
  124|      8|			return static_cast<std::underlying_type_t<EnumClass>>(value);
  125|      8|		}
_ZNK4pcpp13EnumClassHashINS_20Asn1UniversalTagTypeELb0EEclES1_:
  123|     76|		{
  124|     76|			return static_cast<std::underlying_type_t<EnumClass>>(value);
  125|     76|		}

_ZN4pcpp6Logger11getInstanceEv:
  368|  3.71k|		{
  369|  3.71k|			static Logger instance;
  370|  3.71k|			return instance;
  371|  3.71k|		}
_ZN4pcpp6Logger12suppressLogsEv:
  320|    781|		{
  321|    781|			m_LogsEnabled = false;
  322|    781|		}
_ZN4pcpp9LogSourceC2ENS_9LogModuleEPKcS3_i:
  138|  1.17k|		    : file(file), function(function), line(line), logModule(logModule)
  139|  1.17k|		{}
_ZN4pcpp8internal10LogContext4initENS_8LogLevelERKNS_9LogSourceE:
  188|  1.17k|			{
  189|  1.17k|				m_Source = source;
  190|  1.17k|				m_Level = level;
  191|  1.17k|				m_Stream.clear();
  192|  1.17k|				m_Stream.str({});
  193|  1.17k|			}
_ZNK4pcpp6Logger9shouldLogENS_8LogLevelENS_9LogModuleE:
  288|  2.93k|		{
  289|  2.93k|			return level != LogLevel::Off && m_LogModulesArray[module] >= level;
  ------------------
  |  Branch (289:11): [True: 2.93k, False: 0]
  |  Branch (289:37): [True: 1.17k, False: 1.75k]
  ------------------
  290|  2.93k|		}
_ZN4pcpp8internal10LogContextlsINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEERS1_RKT_:
  199|    146|			{
  200|    146|				m_Stream << value;
  201|    146|				return *this;
  202|    146|			}
_ZN4pcpp8internal10LogContextlsIA2_cEERS1_RKT_:
  199|     26|			{
  200|     26|				m_Stream << value;
  201|     26|				return *this;
  202|     26|			}
_ZN4pcpp8internal10LogContextlsIA29_cEERS1_RKT_:
  199|     10|			{
  200|     10|				m_Stream << value;
  201|     10|				return *this;
  202|     10|			}
_ZN4pcpp8internal10LogContextlsIA86_cEERS1_RKT_:
  199|      4|			{
  200|      4|				m_Stream << value;
  201|      4|				return *this;
  202|      4|			}
_ZN4pcpp8internal10LogContextlsIFRNSt3__18ios_baseES5_EEERS1_RKT_:
  199|      4|			{
  200|      4|				m_Stream << value;
  201|      4|				return *this;
  202|      4|			}
_ZN4pcpp8internal10LogContextlsIjEERS1_RKT_:
  199|  1.85k|			{
  200|  1.85k|				m_Stream << value;
  201|  1.85k|				return *this;
  202|  1.85k|			}
_ZN4pcpp8internal10LogContextlsIA32_cEERS1_RKT_:
  199|     59|			{
  200|     59|				m_Stream << value;
  201|     59|				return *this;
  202|     59|			}
_ZN4pcpp8internal10LogContextlsIA26_cEERS1_RKT_:
  199|     40|			{
  200|     40|				m_Stream << value;
  201|     40|				return *this;
  202|     40|			}
_ZN4pcpp8internal10LogContextlsIA31_cEERS1_RKT_:
  199|    930|			{
  200|    930|				m_Stream << value;
  201|    930|				return *this;
  202|    930|			}
_ZN4pcpp8internal10LogContextlsIA24_cEERS1_RKT_:
  199|    959|			{
  200|    959|				m_Stream << value;
  201|    959|				return *this;
  202|    959|			}
_ZN4pcpp8internal10LogContextlsIA23_cEERS1_RKT_:
  199|     31|			{
  200|     31|				m_Stream << value;
  201|     31|				return *this;
  202|     31|			}
_ZN4pcpp8internal10LogContextlsIA27_cEERS1_RKT_:
  199|     80|			{
  200|     80|				m_Stream << value;
  201|     80|				return *this;
  202|     80|			}
_ZN4pcpp9LogSourceC2Ev:
  125|      2|		constexpr LogSource() = default;
_ZN4pcpp8internal10LogContextC2Ev:
  176|      2|			LogContext() = default;

_ZN4pcpp10MacAddressC2Ehhhhhh:
   73|      4|		    : m_Address{ firstOctet, secondOctet, thirdOctet, fourthOctet, fifthOctet, sixthOctet }
   74|      4|		{}
_ZN4pcpp10MacAddressC2IA18_cvEERKT_:
   61|      4|		MacAddress(const T& addr) : MacAddress(static_cast<std::string>(addr))
   62|      4|		{}

_ZN4pcpp8internal17DynamicObjectPoolINS0_10LogContextELb1EED2Ev:
   57|      1|			{
   58|      1|				clear();
   59|      1|			}
_ZN4pcpp8internal17DynamicObjectPoolINS0_10LogContextELb1EE5clearEv:
  175|      1|			{
  176|      1|				std::unique_lock<std::mutex> lock(m_Mutex);
  177|      3|				while (!m_Pool.empty())
  ------------------
  |  Branch (177:12): [True: 2, False: 1]
  ------------------
  178|      2|				{
  179|      2|					delete m_Pool.top();
  180|      2|					m_Pool.pop();
  181|      2|				}
  182|      1|			}
_ZN4pcpp8internal17DynamicObjectPoolINS0_10LogContextELb1EE11preallocateEm:
  158|      1|			{
  159|      1|				std::unique_lock<std::mutex> lock(m_Mutex);
  160|       |
  161|      1|				if (m_MaxPoolSize < count)
  ------------------
  |  Branch (161:9): [True: 0, False: 1]
  ------------------
  162|      0|				{
  163|      0|					throw std::invalid_argument("Preallocated objects cannot exceed the maximum pool size");
  164|      0|				}
  165|       |
  166|       |				// If the pool is already larger than the requested count, we don't need to do anything.
  167|      3|				for (std::size_t i = m_Pool.size(); i < count; i++)
  ------------------
  |  Branch (167:41): [True: 2, False: 1]
  ------------------
  168|      2|				{
  169|      2|					m_Pool.push(new T());
  170|      2|				}
  171|      1|			}
_ZN4pcpp8internal17DynamicObjectPoolINS0_10LogContextELb1EEC2Emm:
   36|      1|			    : m_MaxPoolSize(maxPoolSize)
   37|      1|			{
   38|      1|				if (initialSize > maxPoolSize)
  ------------------
  |  Branch (38:9): [True: 0, False: 1]
  ------------------
   39|      0|				{
   40|      0|					throw std::invalid_argument("Preallocated objects cannot exceed the maximum pool size");
   41|      0|				}
   42|       |
   43|      1|				if (initialSize > 0)
  ------------------
  |  Branch (43:9): [True: 1, False: 0]
  ------------------
   44|      1|				{
   45|      1|					this->preallocate(initialSize);
   46|      1|				}
   47|      1|			}
_ZN4pcpp8internal17DynamicObjectPoolINS0_10LogContextELb1EE13acquireObjectEv:
   68|  1.17k|			{
   69|  1.17k|				return std::unique_ptr<T>(acquireObjectRaw());
   70|  1.17k|			}
_ZN4pcpp8internal17DynamicObjectPoolINS0_10LogContextELb1EE16acquireObjectRawEv:
   79|  1.17k|			{
   80|  1.17k|				std::unique_lock<std::mutex> lock(m_Mutex);
   81|       |
   82|  1.17k|				if (m_Pool.empty())
  ------------------
  |  Branch (82:9): [True: 0, False: 1.17k]
  ------------------
   83|      0|				{
   84|       |					// We don't need the lock anymore, so release it.
   85|      0|					lock.unlock();
   86|      0|					return new T();
   87|      0|				}
   88|       |
   89|  1.17k|				T* obj = m_Pool.top();
   90|  1.17k|				m_Pool.pop();
   91|  1.17k|				return obj;
   92|  1.17k|			}
_ZN4pcpp8internal17DynamicObjectPoolINS0_10LogContextELb1EE13releaseObjectENSt3__110unique_ptrIS2_NS4_14default_deleteIS2_EEEE:
  101|  1.17k|			{
  102|  1.17k|				releaseObjectRaw(obj.release());
  103|  1.17k|			}
_ZN4pcpp8internal17DynamicObjectPoolINS0_10LogContextELb1EE16releaseObjectRawEPS2_:
  112|  1.17k|			{
  113|  1.17k|				std::unique_lock<std::mutex> lock(m_Mutex);
  114|       |
  115|  1.17k|				if (m_MaxPoolSize == INFINITE_POOL_SIZE || m_Pool.size() < m_MaxPoolSize)
  ------------------
  |  Branch (115:9): [True: 0, False: 1.17k]
  |  Branch (115:48): [True: 1.17k, False: 0]
  ------------------
  116|  1.17k|				{
  117|  1.17k|					m_Pool.push(obj);
  118|  1.17k|				}
  119|      0|				else
  120|      0|				{
  121|       |					// We don't need the lock anymore, so release it.
  122|      0|					lock.unlock();
  123|      0|					delete obj;
  124|      0|				}
  125|  1.17k|			}

_ZN4pcpp13PointerVectorINS_9RawPacketENSt3__114default_deleteIS1_EEEC2Ev:
   59|    701|		PointerVector() = default;
_ZN4pcpp13PointerVectorINS_9RawPacketENSt3__114default_deleteIS1_EEED2Ev:
   78|    701|		{
   79|    701|			freeVectorUnsafe(m_Vector);
   80|    701|		}
_ZN4pcpp13PointerVectorINS_9RawPacketENSt3__114default_deleteIS1_EEE16freeVectorUnsafeERKNS2_6vectorIPS1_NS2_9allocatorIS7_EEEE:
  362|    701|		{
  363|    701|			for (auto& obj : origin)
  ------------------
  |  Branch (363:19): [True: 355, False: 701]
  ------------------
  364|    355|			{
  365|    355|				Deleter{}(obj);
  366|    355|			}
  367|    701|		}
_ZNK4pcpp13PointerVectorINS_9RawPacketENSt3__114default_deleteIS1_EEE5frontEv:
  238|    355|		{
  239|    355|			return m_Vector.front();
  240|    355|		}
_ZN4pcpp13PointerVectorINS_9RawPacketENSt3__114default_deleteIS1_EEE8pushBackEPS1_b:
  147|    355|		{
  148|    355|			if (element == nullptr)
  ------------------
  |  Branch (148:8): [True: 0, False: 355]
  ------------------
  149|      0|			{
  150|      0|				throw std::invalid_argument("Element is nullptr");
  151|      0|			}
  152|       |
  153|    355|			try
  154|    355|			{
  155|    355|				m_Vector.push_back(element);
  156|    355|			}
  157|    355|			catch (const std::exception&)
  158|    355|			{
  159|      0|				if (freeElementOnError)
  ------------------
  |  Branch (159:9): [True: 0, False: 0]
  ------------------
  160|      0|				{
  161|      0|					Deleter{}(element);
  162|      0|				}
  163|      0|				throw;
  164|      0|			}
  165|    355|		}

_ZN4pcpp15FieldDescriptorC2EtNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEPFNS1_6vectorIS0_NS5_IS0_EEEEvE:
   35|    480|		    : id(fieldId), name(std::move(fieldName)), getChildren(fieldChildren)
   36|    480|		{}
_ZN4pcpp21ObjectFieldDescriptorINS_6Packet16SerializedFields15TimestampObjectEEC2EtNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEE:
   54|      2|		    : FieldDescriptor(fieldId, std::move(fieldName), &Derived::all)
   55|      2|		{}
_ZN4pcpp21ObjectFieldDescriptorINS_9IPv6Layer16SerializedFields19IPv6ExtensionObjectEEC2EtNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEE:
   54|      2|		    : FieldDescriptor(fieldId, std::move(fieldName), &Derived::all)
   55|      2|		{}

_ZN4pcpp11IPv4AddressC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
   64|      4|	{
   65|      4|		if (inet_pton(AF_INET, addrAsString.data(), m_Bytes.data()) <= 0)
  ------------------
  |  Branch (65:7): [True: 0, False: 4]
  ------------------
   66|      0|		{
   67|      0|			throw std::invalid_argument("Not a valid IPv4 address: " + addrAsString);
   68|      0|		}
   69|      4|	}
_ZN4pcpp11IPv6AddressC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  133|      2|	{
  134|      2|		if (inet_pton(AF_INET6, addrAsString.data(), m_Bytes.data()) <= 0)
  ------------------
  |  Branch (134:7): [True: 0, False: 2]
  ------------------
  135|      0|		{
  136|      0|			throw std::invalid_argument("Not a valid IPv6 address: " + addrAsString);
  137|      0|		}
  138|      2|	}

_ZN4pcpp6LoggerC2Ev:
   55|      1|	Logger::Logger() : m_LogsEnabled(true), m_LogPrinter(&printToCerr)
   56|      1|	{
   57|      1|		m_LogModulesArray.fill(LogLevel::Info);
   58|      1|	}
_ZN4pcpp6Logger16createLogContextENS_8LogLevelERKNS_9LogSourceE:
   89|  1.17k|	{
   90|  1.17k|		if (m_UseContextPooling)
  ------------------
  |  Branch (90:7): [True: 1.17k, False: 0]
  ------------------
   91|  1.17k|		{
   92|  1.17k|			auto ctx = m_LogContextPool.acquireObject();
   93|  1.17k|			ctx->init(level, source);
   94|  1.17k|			return ctx;
   95|  1.17k|		}
   96|      0|		return std::make_unique<internal::LogContext>(level, source);
   97|  1.17k|	}
_ZN4pcpp6Logger4emitENSt3__110unique_ptrINS_8internal10LogContextENS1_14default_deleteIS4_EEEE:
  100|  1.17k|	{
  101|  1.17k|		emit(message->m_Source, message->m_Level, message->m_Stream.str());
  102|       |		// Pushes the message back to the pool if pooling is enabled. Otherwise, the message is deleted.
  103|  1.17k|		if (m_UseContextPooling)
  ------------------
  |  Branch (103:7): [True: 1.17k, False: 0]
  ------------------
  104|  1.17k|		{
  105|  1.17k|			m_LogContextPool.releaseObject(std::move(message));
  106|  1.17k|		}
  107|  1.17k|	}
_ZN4pcpp6Logger4emitERKNS_9LogSourceENS_8LogLevelERKNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEE:
  110|  1.17k|	{
  111|       |		// If the log level is an error, save the error to the last error message variable.
  112|  1.17k|		if (logLevel == LogLevel::Error)
  ------------------
  |  Branch (112:7): [True: 283, False: 890]
  ------------------
  113|    283|		{
  114|    283|			static_assert(m_LastError.size() >= 1,
  115|    283|			              "Last error buffer size must be at least 1 to hold a null terminator");
  116|       |
  117|       |			// Copy the message to the last error buffer, leaving space for null terminator
  118|    283|			auto const copied = message.copy(m_LastError.data(), m_LastError.size() - 1);
  119|    283|			m_LastError[copied] = '\0';
  120|    283|		}
  121|  1.17k|		if (m_LogsEnabled)
  ------------------
  |  Branch (121:7): [True: 0, False: 1.17k]
  ------------------
  122|      0|		{
  123|      0|			m_LogPrinter(logLevel, message, source.file, source.function, source.line);
  124|      0|		}
  125|  1.17k|	}

_ZN4pcpp10MacAddressC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
   37|      4|	{
   38|      4|		constexpr size_t validMacAddressLength = 17;
   39|      4|		unsigned int values[6];
   40|      4|		if (address.size() != validMacAddressLength ||
  ------------------
  |  Branch (40:7): [True: 0, False: 4]
  ------------------
   41|       |		    // NOLINTNEXTLINE(cert-err34-c)
   42|      4|		    sscanf(address.c_str(), "%x:%x:%x:%x:%x:%x", &values[0], &values[1], &values[2], &values[3], &values[4],
  ------------------
  |  Branch (42:7): [True: 0, False: 4]
  ------------------
   43|      4|		           &values[5]) != 6)
   44|      0|		{
   45|      0|			throw std::invalid_argument("Invalid MAC address format, should be xx:xx:xx:xx:xx:xx");
   46|      0|		}
   47|     28|		for (int i = 0; i < 6; ++i)
  ------------------
  |  Branch (47:19): [True: 24, False: 4]
  ------------------
   48|     24|		{
   49|     24|			m_Address[i] = values[i];
   50|     24|		}
   51|      4|	}

_ZN4pcpp16GtpV2MessageTypeC2ENS0_5ValueE:
  595|    164|		constexpr GtpV2MessageType(Value value) : m_Value(value)
  596|    164|		{}
_ZNK4pcpp16GtpV2MessageTypecvNS0_5ValueEEv:
  609|    164|		{
  610|    164|			return m_Value;
  611|    164|		}

_ZN4pcpp22HttpResponseStatusCodeC2ENS0_5ValueE:
  416|    344|		HttpResponseStatusCode(Value statusCode) : m_Value(statusCode)
  417|    344|		{}
_ZNK4pcpp22HttpResponseStatusCodecvNS0_5ValueEEv:
  431|    178|		{
  432|    178|			return m_Value;
  433|    178|		}

_ZNK4pcpp9RawPacket10getRawDataEv:
  694|  8.63k|		{
  695|  8.63k|			return m_RawData;
  696|  8.63k|		}
_ZNK4pcpp9RawPacket16getLinkLayerTypeEv:
  701|  8.63k|		{
  702|  8.63k|			return m_LinkLayerType;
  703|  8.63k|		}
_ZNK4pcpp9RawPacket13getRawDataLenEv:
  713|  8.63k|		{
  714|  8.63k|			return m_RawDataLen;
  715|  8.63k|		}
_ZNK4pcpp9RawPacket14getFrameLengthEv:
  720|  4.31k|		{
  721|  4.31k|			return m_FrameLength;
  722|  4.31k|		}
_ZNK4pcpp9RawPacket18getPacketTimeStampEv:
  726|  8.63k|		{
  727|  8.63k|			return m_TimeStamp;
  728|  8.63k|		}
_ZN4pcpp9RawPacketC2Ev:
  544|    701|		RawPacket() = default;

_ZN4pcpp14SSLCipherSuiteC2EtNS_23SSLKeyExchangeAlgorithmENS_26SSLAuthenticationAlgorithmENS_31SSLSymmetricEncryptionAlgorithmENS_19SSLHashingAlgorithmEPKc:
   36|    658|		    : m_Id(id), m_KeyExAlg(keyExAlg), m_AuthAlg(authAlg), m_SymKeyAlg(symKeyAlg), m_MACAlg(MACAlg), m_Name(name)
   37|    658|		{}

_ZN4pcpp33createGtpV1MessageTypeToStringMapEv:
  440|      2|	{
  441|      2|		std::unordered_map<uint8_t, std::string> tempMap;
  442|       |
  443|      2|		tempMap[0] = "GTPv1 Message Type Unknown";
  444|      2|		tempMap[1] = "Echo Request";
  445|      2|		tempMap[2] = "Echo Response";
  446|      2|		tempMap[3] = "Version Not Supported";
  447|      2|		tempMap[4] = "Node Alive Request";
  448|      2|		tempMap[5] = "Node Alive Response";
  449|      2|		tempMap[6] = "Redirection Request";
  450|      2|		tempMap[7] = "Create PDP Context Request";
  451|      2|		tempMap[16] = "Create PDP Context Response";
  452|      2|		tempMap[17] = "Update PDP Context Request";
  453|      2|		tempMap[18] = "Update PDP Context Response";
  454|      2|		tempMap[19] = "Delete PDP Context Request";
  455|      2|		tempMap[20] = "Delete PDP Context Response";
  456|      2|		tempMap[22] = "Initiate PDP Context Activation Request";
  457|      2|		tempMap[23] = "Initiate PDP Context Activation Response";
  458|      2|		tempMap[26] = "Error Indication";
  459|      2|		tempMap[27] = "PDU Notification Request";
  460|      2|		tempMap[28] = "PDU Notification Response";
  461|      2|		tempMap[29] = "PDU Notification Reject Request";
  462|      2|		tempMap[30] = "PDU Notification Reject Response";
  463|      2|		tempMap[31] = "Supported Extensions Header Notification";
  464|      2|		tempMap[32] = "Send Routing for GPRS Request";
  465|      2|		tempMap[33] = "Send Routing for GPRS Response";
  466|      2|		tempMap[34] = "Failure Report Request";
  467|      2|		tempMap[35] = "Failure Report Response";
  468|      2|		tempMap[36] = "Note MS Present Request";
  469|      2|		tempMap[37] = "Note MS Present Response";
  470|      2|		tempMap[38] = "Identification Request";
  471|      2|		tempMap[39] = "Identification Response";
  472|      2|		tempMap[50] = "SGSN Context Request";
  473|      2|		tempMap[51] = "SGSN Context Response";
  474|      2|		tempMap[52] = "SGSN Context Acknowledge";
  475|      2|		tempMap[53] = "Forward Relocation Request";
  476|      2|		tempMap[54] = "Forward Relocation Response";
  477|      2|		tempMap[55] = "Forward Relocation Complete";
  478|      2|		tempMap[56] = "Relocation Cancel Request";
  479|      2|		tempMap[57] = "Relocation Cancel Response";
  480|      2|		tempMap[58] = "Forward SRNS Context";
  481|      2|		tempMap[59] = "Forward Relocation Complete Acknowledge";
  482|      2|		tempMap[60] = "Forward SRNS Context Acknowledge";
  483|      2|		tempMap[61] = "UE Registration Request";
  484|      2|		tempMap[62] = "UE Registration Response";
  485|      2|		tempMap[70] = "RAN Information Relay";
  486|      2|		tempMap[96] = "MBMS Notification Request";
  487|      2|		tempMap[97] = "MBMS Notification Response";
  488|      2|		tempMap[98] = "MBMS Notification Reject Request";
  489|      2|		tempMap[99] = "MBMS Notification Reject Response";
  490|      2|		tempMap[100] = "Create MBMS Notification Request";
  491|      2|		tempMap[101] = "Create MBMS Notification Response";
  492|      2|		tempMap[102] = "Update MBMS Notification Request";
  493|      2|		tempMap[103] = "Update MBMS Notification Response";
  494|      2|		tempMap[104] = "Delete MBMS Notification Request";
  495|      2|		tempMap[105] = "Delete MBMS Notification Response";
  496|      2|		tempMap[112] = "MBMS Registration Request";
  497|      2|		tempMap[113] = "MBMS Registration Response";
  498|      2|		tempMap[114] = "MBMS De-Registration Request";
  499|      2|		tempMap[115] = "MBMS De-Registration Response";
  500|      2|		tempMap[116] = "MBMS Session Start Request";
  501|      2|		tempMap[117] = "MBMS Session Start Response";
  502|      2|		tempMap[118] = "MBMS Session Stop Request";
  503|      2|		tempMap[119] = "MBMS Session Stop Response";
  504|      2|		tempMap[120] = "MBMS Session Update Request";
  505|      2|		tempMap[121] = "MBMS Session Update Response";
  506|      2|		tempMap[128] = "MS Info Change Request";
  507|      2|		tempMap[129] = "MS Info Change Response";
  508|      2|		tempMap[240] = "Data Record Transfer Request";
  509|      2|		tempMap[241] = "Data Record Transfer Response";
  510|      2|		tempMap[254] = "End Marker";
  511|      2|		tempMap[255] = "G-PDU";
  512|       |
  513|      2|		return tempMap;
  514|      2|	}
_ZNK4pcpp20GtpV2MessageTypeHashclERKNS_16GtpV2MessageTypeE:
  680|    164|		{
  681|    164|			return static_cast<uint8_t>(messageType);
  682|    164|		}

_ZNK4pcpp26HttpResponseStatusCodeHashclERKNS_22HttpResponseStatusCodeE:
  555|    178|		{
  556|    178|			return static_cast<int>(status);
  557|    178|		}

_ZN4pcpp29createPPPNextProtoToStringMapEv:
  103|      2|	{
  104|      2|		std::unordered_map<uint16_t, std::string> tempMap;
  105|      2|		tempMap[PCPP_PPP_PADDING] = "Padding Protocol";
  ------------------
  |  |  451|      2|#define PCPP_PPP_PADDING 0x1
  ------------------
  106|      2|		tempMap[PCPP_PPP_ROHC_SCID] = "ROHC small-CID";
  ------------------
  |  |  453|      2|#define PCPP_PPP_ROHC_SCID 0x3
  ------------------
  107|      2|		tempMap[PCPP_PPP_ROHC_LCID] = "ROHC large-CID";
  ------------------
  |  |  455|      2|#define PCPP_PPP_ROHC_LCID 0x5
  ------------------
  108|      2|		tempMap[PCPP_PPP_IP] = "Internet Protocol version 4";
  ------------------
  |  |  457|      2|#define PCPP_PPP_IP 0x21
  ------------------
  109|      2|		tempMap[PCPP_PPP_OSI] = "OSI Network Layer";
  ------------------
  |  |  459|      2|#define PCPP_PPP_OSI 0x23
  ------------------
  110|      2|		tempMap[PCPP_PPP_XNSIDP] = "Xerox NS IDP";
  ------------------
  |  |  461|      2|#define PCPP_PPP_XNSIDP 0x25
  ------------------
  111|      2|		tempMap[PCPP_PPP_DEC4] = "DECnet Phase IV";
  ------------------
  |  |  463|      2|#define PCPP_PPP_DEC4 0x27
  ------------------
  112|      2|		tempMap[PCPP_PPP_AT] = "Appletalk";
  ------------------
  |  |  465|      2|#define PCPP_PPP_AT 0x29
  ------------------
  113|      2|		tempMap[PCPP_PPP_IPX] = "Novell IPX";
  ------------------
  |  |  467|      2|#define PCPP_PPP_IPX 0x2b
  ------------------
  114|      2|		tempMap[PCPP_PPP_VJC_COMP] = "Van Jacobson Compressed TCP/IP";
  ------------------
  |  |  469|      2|#define PCPP_PPP_VJC_COMP 0x2d
  ------------------
  115|      2|		tempMap[PCPP_PPP_VJC_UNCOMP] = "Van Jacobson Uncompressed TCP/IP";
  ------------------
  |  |  471|      2|#define PCPP_PPP_VJC_UNCOMP 0x2f
  ------------------
  116|      2|		tempMap[PCPP_PPP_BCP] = "Bridging PDU";
  ------------------
  |  |  473|      2|#define PCPP_PPP_BCP 0x31
  ------------------
  117|      2|		tempMap[PCPP_PPP_ST] = "Stream Protocol (ST-II)";
  ------------------
  |  |  475|      2|#define PCPP_PPP_ST 0x33
  ------------------
  118|      2|		tempMap[PCPP_PPP_VINES] = "Banyan Vines";
  ------------------
  |  |  477|      2|#define PCPP_PPP_VINES 0x35
  ------------------
  119|      2|		tempMap[PCPP_PPP_AT_EDDP] = "AppleTalk EDDP";
  ------------------
  |  |  479|      2|#define PCPP_PPP_AT_EDDP 0x39
  ------------------
  120|      2|		tempMap[PCPP_PPP_AT_SB] = "AppleTalk SmartBuffered";
  ------------------
  |  |  481|      2|#define PCPP_PPP_AT_SB 0x3b
  ------------------
  121|      2|		tempMap[PCPP_PPP_MP] = "Multi-Link";
  ------------------
  |  |  483|      2|#define PCPP_PPP_MP 0x3d
  ------------------
  122|      2|		tempMap[PCPP_PPP_NB] = "NETBIOS Framing";
  ------------------
  |  |  485|      2|#define PCPP_PPP_NB 0x3f
  ------------------
  123|      2|		tempMap[PCPP_PPP_CISCO] = "Cisco Systems";
  ------------------
  |  |  487|      2|#define PCPP_PPP_CISCO 0x41
  ------------------
  124|      2|		tempMap[PCPP_PPP_ASCOM] = "Ascom Timeplex";
  ------------------
  |  |  489|      2|#define PCPP_PPP_ASCOM 0x43
  ------------------
  125|      2|		tempMap[PCPP_PPP_LBLB] = "Fujitsu Link Backup and Load Balancing (LBLB)";
  ------------------
  |  |  491|      2|#define PCPP_PPP_LBLB 0x45
  ------------------
  126|      2|		tempMap[PCPP_PPP_RL] = "DCA Remote Lan";
  ------------------
  |  |  493|      2|#define PCPP_PPP_RL 0x47
  ------------------
  127|      2|		tempMap[PCPP_PPP_SDTP] = "Serial Data Transport Protocol (PPP-SDTP)";
  ------------------
  |  |  495|      2|#define PCPP_PPP_SDTP 0x49
  ------------------
  128|      2|		tempMap[PCPP_PPP_LLC] = "SNA over 802.2";
  ------------------
  |  |  497|      2|#define PCPP_PPP_LLC 0x4b
  ------------------
  129|      2|		tempMap[PCPP_PPP_SNA] = "SNA";
  ------------------
  |  |  499|      2|#define PCPP_PPP_SNA 0x4d
  ------------------
  130|      2|		tempMap[PCPP_PPP_IPV6HC] = "IPv6 Header Compression ";
  ------------------
  |  |  501|      2|#define PCPP_PPP_IPV6HC 0x4f
  ------------------
  131|      2|		tempMap[PCPP_PPP_KNX] = "KNX Bridging Data";
  ------------------
  |  |  503|      2|#define PCPP_PPP_KNX 0x51
  ------------------
  132|      2|		tempMap[PCPP_PPP_ENCRYPT] = "Encryption";
  ------------------
  |  |  505|      2|#define PCPP_PPP_ENCRYPT 0x53
  ------------------
  133|      2|		tempMap[PCPP_PPP_ILE] = "Individual Link Encryption";
  ------------------
  |  |  507|      2|#define PCPP_PPP_ILE 0x55
  ------------------
  134|      2|		tempMap[PCPP_PPP_IPV6] = "Internet Protocol version 6";
  ------------------
  |  |  509|      2|#define PCPP_PPP_IPV6 0x57
  ------------------
  135|      2|		tempMap[PCPP_PPP_MUX] = "PPP Muxing";
  ------------------
  |  |  511|      2|#define PCPP_PPP_MUX 0x59
  ------------------
  136|      2|		tempMap[PCPP_PPP_VSNP] = "Vendor-Specific Network Protocol (VSNP)";
  ------------------
  |  |  513|      2|#define PCPP_PPP_VSNP 0x5b
  ------------------
  137|      2|		tempMap[PCPP_PPP_TNP] = "TRILL Network Protocol (TNP)";
  ------------------
  |  |  515|      2|#define PCPP_PPP_TNP 0x5d
  ------------------
  138|      2|		tempMap[PCPP_PPP_RTP_FH] = "RTP IPHC Full Header";
  ------------------
  |  |  517|      2|#define PCPP_PPP_RTP_FH 0x61
  ------------------
  139|      2|		tempMap[PCPP_PPP_RTP_CTCP] = "RTP IPHC Compressed TCP";
  ------------------
  |  |  519|      2|#define PCPP_PPP_RTP_CTCP 0x63
  ------------------
  140|      2|		tempMap[PCPP_PPP_RTP_CNTCP] = "RTP IPHC Compressed Non TCP";
  ------------------
  |  |  521|      2|#define PCPP_PPP_RTP_CNTCP 0x65
  ------------------
  141|      2|		tempMap[PCPP_PPP_RTP_CUDP8] = "RTP IPHC Compressed UDP 8";
  ------------------
  |  |  523|      2|#define PCPP_PPP_RTP_CUDP8 0x67
  ------------------
  142|      2|		tempMap[PCPP_PPP_RTP_CRTP8] = "RTP IPHC Compressed RTP 8";
  ------------------
  |  |  525|      2|#define PCPP_PPP_RTP_CRTP8 0x69
  ------------------
  143|      2|		tempMap[PCPP_PPP_STAMPEDE] = "Stampede Bridging";
  ------------------
  |  |  527|      2|#define PCPP_PPP_STAMPEDE 0x6f
  ------------------
  144|      2|		tempMap[PCPP_PPP_MPPLUS] = "MP+ Protocol";
  ------------------
  |  |  529|      2|#define PCPP_PPP_MPPLUS 0x73
  ------------------
  145|      2|		tempMap[PCPP_PPP_NTCITS_IPI] = "NTCITS IPI";
  ------------------
  |  |  531|      2|#define PCPP_PPP_NTCITS_IPI 0xc1
  ------------------
  146|      2|		tempMap[PCPP_PPP_ML_SLCOMP] = "Single link compression in multilink";
  ------------------
  |  |  533|      2|#define PCPP_PPP_ML_SLCOMP 0xfb
  ------------------
  147|      2|		tempMap[PCPP_PPP_COMP] = "Compressed datagram";
  ------------------
  |  |  535|      2|#define PCPP_PPP_COMP 0xfd
  ------------------
  148|      2|		tempMap[PCPP_PPP_STP_HELLO] = "802.1d Hello Packets";
  ------------------
  |  |  537|      2|#define PCPP_PPP_STP_HELLO 0x0201
  ------------------
  149|      2|		tempMap[PCPP_PPP_IBM_SR] = "IBM Source Routing BPDU";
  ------------------
  |  |  539|      2|#define PCPP_PPP_IBM_SR 0x0203
  ------------------
  150|      2|		tempMap[PCPP_PPP_DEC_LB] = "DEC LANBridge100 Spanning Tree";
  ------------------
  |  |  541|      2|#define PCPP_PPP_DEC_LB 0x0205
  ------------------
  151|      2|		tempMap[PCPP_PPP_CDP] = "Cisco Discovery Protocol";
  ------------------
  |  |  543|      2|#define PCPP_PPP_CDP 0x0207
  ------------------
  152|      2|		tempMap[PCPP_PPP_NETCS] = "Netcs Twin Routing";
  ------------------
  |  |  545|      2|#define PCPP_PPP_NETCS 0x0209
  ------------------
  153|      2|		tempMap[PCPP_PPP_STP] = "STP - Scheduled Transfer Protocol";
  ------------------
  |  |  547|      2|#define PCPP_PPP_STP 0x020b
  ------------------
  154|      2|		tempMap[PCPP_PPP_EDP] = "EDP - Extreme Discovery Protocol";
  ------------------
  |  |  549|      2|#define PCPP_PPP_EDP 0x020d
  ------------------
  155|      2|		tempMap[PCPP_PPP_OSCP] = "Optical Supervisory Channel Protocol (OSCP)";
  ------------------
  |  |  551|      2|#define PCPP_PPP_OSCP 0x0211
  ------------------
  156|      2|		tempMap[PCPP_PPP_OSCP2] = "Optical Supervisory Channel Protocol (OSCP)";
  ------------------
  |  |  553|      2|#define PCPP_PPP_OSCP2 0x0213
  ------------------
  157|      2|		tempMap[PCPP_PPP_LUXCOM] = "Luxcom";
  ------------------
  |  |  555|      2|#define PCPP_PPP_LUXCOM 0x0231
  ------------------
  158|      2|		tempMap[PCPP_PPP_SIGMA] = "Sigma Network Systems";
  ------------------
  |  |  557|      2|#define PCPP_PPP_SIGMA 0x0233
  ------------------
  159|      2|		tempMap[PCPP_PPP_ACSP] = "Apple Client Server Protocol";
  ------------------
  |  |  559|      2|#define PCPP_PPP_ACSP 0x0235
  ------------------
  160|      2|		tempMap[PCPP_PPP_MPLS_UNI] = "MPLS Unicast";
  ------------------
  |  |  561|      2|#define PCPP_PPP_MPLS_UNI 0x0281
  ------------------
  161|      2|		tempMap[PCPP_PPP_MPLS_MULTI] = "MPLS Multicast";
  ------------------
  |  |  563|      2|#define PCPP_PPP_MPLS_MULTI 0x0283
  ------------------
  162|      2|		tempMap[PCPP_PPP_P12844] = "IEEE p1284.4 standard - data packets";
  ------------------
  |  |  565|      2|#define PCPP_PPP_P12844 0x0285
  ------------------
  163|      2|		tempMap[PCPP_PPP_TETRA] = "ETSI TETRA Network Protocol Type 1";
  ------------------
  |  |  567|      2|#define PCPP_PPP_TETRA 0x0287
  ------------------
  164|      2|		tempMap[PCPP_PPP_MFTP] = "Multichannel Flow Treatment Protocol";
  ------------------
  |  |  569|      2|#define PCPP_PPP_MFTP 0x0289
  ------------------
  165|      2|		tempMap[PCPP_PPP_RTP_CTCPND] = "RTP IPHC Compressed TCP No Delta";
  ------------------
  |  |  571|      2|#define PCPP_PPP_RTP_CTCPND 0x2063
  ------------------
  166|      2|		tempMap[PCPP_PPP_RTP_CS] = "RTP IPHC Context State";
  ------------------
  |  |  573|      2|#define PCPP_PPP_RTP_CS 0x2065
  ------------------
  167|      2|		tempMap[PCPP_PPP_RTP_CUDP16] = "RTP IPHC Compressed UDP 16";
  ------------------
  |  |  575|      2|#define PCPP_PPP_RTP_CUDP16 0x2067
  ------------------
  168|      2|		tempMap[PCPP_PPP_RTP_CRDP16] = "RTP IPHC Compressed RTP 16";
  ------------------
  |  |  577|      2|#define PCPP_PPP_RTP_CRDP16 0x2069
  ------------------
  169|      2|		tempMap[PCPP_PPP_CCCP] = "Cray Communications Control Protocol";
  ------------------
  |  |  579|      2|#define PCPP_PPP_CCCP 0x4001
  ------------------
  170|      2|		tempMap[PCPP_PPP_CDPD_MNRP] = "CDPD Mobile Network Registration Protocol";
  ------------------
  |  |  581|      2|#define PCPP_PPP_CDPD_MNRP 0x4003
  ------------------
  171|      2|		tempMap[PCPP_PPP_EXPANDAP] = "Expand accelerator protocol";
  ------------------
  |  |  583|      2|#define PCPP_PPP_EXPANDAP 0x4005
  ------------------
  172|      2|		tempMap[PCPP_PPP_ODSICP] = "ODSICP NCP";
  ------------------
  |  |  585|      2|#define PCPP_PPP_ODSICP 0x4007
  ------------------
  173|      2|		tempMap[PCPP_PPP_DOCSIS] = "DOCSIS DLL";
  ------------------
  |  |  587|      2|#define PCPP_PPP_DOCSIS 0x4009
  ------------------
  174|      2|		tempMap[PCPP_PPP_CETACEANNDP] = "Cetacean Network Detection Protocol";
  ------------------
  |  |  589|      2|#define PCPP_PPP_CETACEANNDP 0x400b
  ------------------
  175|      2|		tempMap[PCPP_PPP_LZS] = "Stacker LZS";
  ------------------
  |  |  591|      2|#define PCPP_PPP_LZS 0x4021
  ------------------
  176|      2|		tempMap[PCPP_PPP_REFTEK] = "RefTek Protocol";
  ------------------
  |  |  593|      2|#define PCPP_PPP_REFTEK 0x4023
  ------------------
  177|      2|		tempMap[PCPP_PPP_FC] = "Fibre Channel";
  ------------------
  |  |  595|      2|#define PCPP_PPP_FC 0x4025
  ------------------
  178|      2|		tempMap[PCPP_PPP_EMIT] = "EMIT Protocols";
  ------------------
  |  |  597|      2|#define PCPP_PPP_EMIT 0x4027
  ------------------
  179|      2|		tempMap[PCPP_PPP_VSP] = "Vendor-Specific Protocol (VSP)";
  ------------------
  |  |  599|      2|#define PCPP_PPP_VSP 0x405b
  ------------------
  180|      2|		tempMap[PCPP_PPP_TLSP] = "TRILL Link State Protocol (TLSP)";
  ------------------
  |  |  601|      2|#define PCPP_PPP_TLSP 0x405d
  ------------------
  181|      2|		tempMap[PCPP_PPP_IPCP] = "Internet Protocol Control Protocol";
  ------------------
  |  |  603|      2|#define PCPP_PPP_IPCP 0x8021
  ------------------
  182|      2|		tempMap[PCPP_PPP_OSINLCP] = "OSI Network Layer Control Protocol";
  ------------------
  |  |  605|      2|#define PCPP_PPP_OSINLCP 0x8023
  ------------------
  183|      2|		tempMap[PCPP_PPP_XNSIDPCP] = "Xerox NS IDP Control Protocol";
  ------------------
  |  |  607|      2|#define PCPP_PPP_XNSIDPCP 0x8025
  ------------------
  184|      2|		tempMap[PCPP_PPP_DECNETCP] = "DECnet Phase IV Control Protocol";
  ------------------
  |  |  609|      2|#define PCPP_PPP_DECNETCP 0x8027
  ------------------
  185|      2|		tempMap[PCPP_PPP_ATCP] = "AppleTalk Control Protocol";
  ------------------
  |  |  611|      2|#define PCPP_PPP_ATCP 0x8029
  ------------------
  186|      2|		tempMap[PCPP_PPP_IPXCP] = "Novell IPX Control Protocol";
  ------------------
  |  |  613|      2|#define PCPP_PPP_IPXCP 0x802b
  ------------------
  187|      2|		tempMap[PCPP_PPP_BRIDGENCP] = "Bridging NCP";
  ------------------
  |  |  615|      2|#define PCPP_PPP_BRIDGENCP 0x8031
  ------------------
  188|      2|		tempMap[PCPP_PPP_SPCP] = "Stream Protocol Control Protocol";
  ------------------
  |  |  617|      2|#define PCPP_PPP_SPCP 0x8033
  ------------------
  189|      2|		tempMap[PCPP_PPP_BVCP] = "Banyan Vines Control Protocol";
  ------------------
  |  |  619|      2|#define PCPP_PPP_BVCP 0x8035
  ------------------
  190|      2|		tempMap[PCPP_PPP_MLCP] = "Multi-Link Control Protocol";
  ------------------
  |  |  621|      2|#define PCPP_PPP_MLCP 0x803d
  ------------------
  191|      2|		tempMap[PCPP_PPP_NBCP] = "NETBIOS Framing Control Protocol";
  ------------------
  |  |  623|      2|#define PCPP_PPP_NBCP 0x803f
  ------------------
  192|      2|		tempMap[PCPP_PPP_CISCOCP] = "Cisco Systems Control Protocol";
  ------------------
  |  |  625|      2|#define PCPP_PPP_CISCOCP 0x8041
  ------------------
  193|      2|		tempMap[PCPP_PPP_ASCOMCP] = "Ascom Timeplex";
  ------------------
  |  |  627|      2|#define PCPP_PPP_ASCOMCP 0x8043
  ------------------
  194|      2|		tempMap[PCPP_PPP_LBLBCP] = "Fujitsu LBLB Control Protocol";
  ------------------
  |  |  629|      2|#define PCPP_PPP_LBLBCP 0x8045
  ------------------
  195|      2|		tempMap[PCPP_PPP_RLNCP] = "DCA Remote Lan Network Control Protocol (RLNCP)";
  ------------------
  |  |  631|      2|#define PCPP_PPP_RLNCP 0x8047
  ------------------
  196|      2|		tempMap[PCPP_PPP_SDCP] = "Serial Data Control Protocol (PPP-SDCP)";
  ------------------
  |  |  633|      2|#define PCPP_PPP_SDCP 0x8049
  ------------------
  197|      2|		tempMap[PCPP_PPP_LLCCP] = "SNA over 802.2 Control Protocol";
  ------------------
  |  |  635|      2|#define PCPP_PPP_LLCCP 0x804b
  ------------------
  198|      2|		tempMap[PCPP_PPP_SNACP] = "SNA Control Protocol";
  ------------------
  |  |  637|      2|#define PCPP_PPP_SNACP 0x804d
  ------------------
  199|      2|		tempMap[PCPP_PPP_IP6HCCP] = "IP6 Header Compression Control Protocol";
  ------------------
  |  |  639|      2|#define PCPP_PPP_IP6HCCP 0x804f
  ------------------
  200|      2|		tempMap[PCPP_PPP_KNXCP] = "KNX Bridging Control Protocol";
  ------------------
  |  |  641|      2|#define PCPP_PPP_KNXCP 0x8051
  ------------------
  201|      2|		tempMap[PCPP_PPP_ECP] = "Encryption Control Protocol";
  ------------------
  |  |  643|      2|#define PCPP_PPP_ECP 0x8053
  ------------------
  202|      2|		tempMap[PCPP_PPP_ILECP] = "Individual Link Encryption Control Protocol";
  ------------------
  |  |  645|      2|#define PCPP_PPP_ILECP 0x8055
  ------------------
  203|      2|		tempMap[PCPP_PPP_IPV6CP] = "IPv6 Control Protocol";
  ------------------
  |  |  647|      2|#define PCPP_PPP_IPV6CP 0x8057
  ------------------
  204|      2|		tempMap[PCPP_PPP_MUXCP] = "PPP Muxing Control Protocol";
  ------------------
  |  |  649|      2|#define PCPP_PPP_MUXCP 0x8059
  ------------------
  205|      2|		tempMap[PCPP_PPP_VSNCP] = "Vendor-Specific Network Control Protocol (VSNCP)";
  ------------------
  |  |  651|      2|#define PCPP_PPP_VSNCP 0x805b
  ------------------
  206|      2|		tempMap[PCPP_PPP_TNCP] = "TRILL Network Control Protocol";
  ------------------
  |  |  653|      2|#define PCPP_PPP_TNCP 0x805d
  ------------------
  207|      2|		tempMap[PCPP_PPP_STAMPEDECP] = "Stampede Bridging Control Protocol";
  ------------------
  |  |  655|      2|#define PCPP_PPP_STAMPEDECP 0x806f
  ------------------
  208|      2|		tempMap[PCPP_PPP_MPPCP] = "MP+ Control Protocol";
  ------------------
  |  |  657|      2|#define PCPP_PPP_MPPCP 0x8073
  ------------------
  209|      2|		tempMap[PCPP_PPP_IPICP] = "NTCITS IPI Control Protocol";
  ------------------
  |  |  659|      2|#define PCPP_PPP_IPICP 0x80c1
  ------------------
  210|      2|		tempMap[PCPP_PPP_SLCC] = "Single link compression in multilink control";
  ------------------
  |  |  661|      2|#define PCPP_PPP_SLCC 0x80fb
  ------------------
  211|      2|		tempMap[PCPP_PPP_CCP] = "Compression Control Protocol";
  ------------------
  |  |  663|      2|#define PCPP_PPP_CCP 0x80fd
  ------------------
  212|      2|		tempMap[PCPP_PPP_CDPCP] = "Cisco Discovery Protocol Control Protocol";
  ------------------
  |  |  665|      2|#define PCPP_PPP_CDPCP 0x8207
  ------------------
  213|      2|		tempMap[PCPP_PPP_NETCSCP] = "Netcs Twin Routing";
  ------------------
  |  |  667|      2|#define PCPP_PPP_NETCSCP 0x8209
  ------------------
  214|      2|		tempMap[PCPP_PPP_STPCP] = "STP - Control Protocol";
  ------------------
  |  |  669|      2|#define PCPP_PPP_STPCP 0x820b
  ------------------
  215|      2|		tempMap[PCPP_PPP_EDPCP] = "EDPCP - Extreme Discovery Protocol Control Protocol";
  ------------------
  |  |  671|      2|#define PCPP_PPP_EDPCP 0x820d
  ------------------
  216|      2|		tempMap[PCPP_PPP_ACSPC] = "Apple Client Server Protocol Control";
  ------------------
  |  |  673|      2|#define PCPP_PPP_ACSPC 0x8235
  ------------------
  217|      2|		tempMap[PCPP_PPP_MPLSCP] = "MPLS Control Protocol";
  ------------------
  |  |  675|      2|#define PCPP_PPP_MPLSCP 0x8281
  ------------------
  218|      2|		tempMap[PCPP_PPP_P12844CP] = "IEEE p1284.4 standard - Protocol Control";
  ------------------
  |  |  677|      2|#define PCPP_PPP_P12844CP 0x8285
  ------------------
  219|      2|		tempMap[PCPP_PPP_TETRACP] = "ETSI TETRA TNP1 Control Protocol";
  ------------------
  |  |  679|      2|#define PCPP_PPP_TETRACP 0x8287
  ------------------
  220|      2|		tempMap[PCPP_PPP_MFTPCP] = "Multichannel Flow Treatment Protocol";
  ------------------
  |  |  681|      2|#define PCPP_PPP_MFTPCP 0x8289
  ------------------
  221|      2|		tempMap[PCPP_PPP_LCP] = "Link Control Protocol";
  ------------------
  |  |  683|      2|#define PCPP_PPP_LCP 0xc021
  ------------------
  222|      2|		tempMap[PCPP_PPP_PAP] = "Password Authentication Protocol";
  ------------------
  |  |  685|      2|#define PCPP_PPP_PAP 0xc023
  ------------------
  223|      2|		tempMap[PCPP_PPP_LQR] = "Link Quality Report";
  ------------------
  |  |  687|      2|#define PCPP_PPP_LQR 0xc025
  ------------------
  224|      2|		tempMap[PCPP_PPP_SPAP] = "Shiva Password Authentication Protocol";
  ------------------
  |  |  689|      2|#define PCPP_PPP_SPAP 0xc027
  ------------------
  225|      2|		tempMap[PCPP_PPP_CBCP] = "Callback Control Protocol (CBCP)";
  ------------------
  |  |  691|      2|#define PCPP_PPP_CBCP 0xc029
  ------------------
  226|      2|		tempMap[PCPP_PPP_BACP] = "BACP Bandwidth Allocation Control Protocol";
  ------------------
  |  |  693|      2|#define PCPP_PPP_BACP 0xc02b
  ------------------
  227|      2|		tempMap[PCPP_PPP_BAP] = "BAP Bandwidth Allocation Protocol";
  ------------------
  |  |  695|      2|#define PCPP_PPP_BAP 0xc02d
  ------------------
  228|      2|		tempMap[PCPP_PPP_VSAP] = "Vendor-Specific Authentication Protocol (VSAP)";
  ------------------
  |  |  697|      2|#define PCPP_PPP_VSAP 0xc05b
  ------------------
  229|      2|		tempMap[PCPP_PPP_CONTCP] = "Container Control Protocol";
  ------------------
  |  |  699|      2|#define PCPP_PPP_CONTCP 0xc081
  ------------------
  230|      2|		tempMap[PCPP_PPP_CHAP] = "Challenge Handshake Authentication Protocol";
  ------------------
  |  |  701|      2|#define PCPP_PPP_CHAP 0xc223
  ------------------
  231|      2|		tempMap[PCPP_PPP_RSAAP] = "RSA Authentication Protocol";
  ------------------
  |  |  703|      2|#define PCPP_PPP_RSAAP 0xc225
  ------------------
  232|      2|		tempMap[PCPP_PPP_EAP] = "Extensible Authentication Protocol";
  ------------------
  |  |  705|      2|#define PCPP_PPP_EAP 0xc227
  ------------------
  233|      2|		tempMap[PCPP_PPP_SIEP] = "Mitsubishi Security Information Exchange Protocol (SIEP)";
  ------------------
  |  |  707|      2|#define PCPP_PPP_SIEP 0xc229
  ------------------
  234|      2|		tempMap[PCPP_PPP_SBAP] = "Stampede Bridging Authorization Protocol";
  ------------------
  |  |  709|      2|#define PCPP_PPP_SBAP 0xc26f
  ------------------
  235|      2|		tempMap[PCPP_PPP_PRPAP] = "Proprietary Authentication Protocol";
  ------------------
  |  |  711|      2|#define PCPP_PPP_PRPAP 0xc281
  ------------------
  236|      2|		tempMap[PCPP_PPP_PRPAP2] = "Proprietary Authentication Protocol";
  ------------------
  |  |  713|      2|#define PCPP_PPP_PRPAP2 0xc283
  ------------------
  237|      2|		tempMap[PCPP_PPP_PRPNIAP] = "Proprietary Node ID Authentication Protocol";
  ------------------
  |  |  715|      2|#define PCPP_PPP_PRPNIAP 0xc481
  ------------------
  238|      2|		return tempMap;
  239|      2|	}

_ZN4pcpp9RawPacketD2Ev:
   22|    701|	{
   23|    701|		RawPacket::clear();
   24|    701|	}
_ZN4pcpp9RawPacket10setRawDataEPKhib8timespecNS_13LinkLayerTypeEi:
   97|  4.31k|	{
   98|  4.31k|		return doSetRawData(pRawData, rawDataLen, takeOwnership, timestamp, layerType, frameLength);
   99|  4.31k|	}
_ZN4pcpp9RawPacket12doSetRawDataEPKhib8timespecNS_13LinkLayerTypeEi:
  103|  4.31k|	{
  104|  4.31k|		clear();
  105|       |
  106|  4.31k|		m_OwnsRawData = takeOwnership;
  107|  4.31k|		m_FrameLength = (frameLength == -1) ? rawDataLen : frameLength;
  ------------------
  |  Branch (107:19): [True: 284, False: 4.03k]
  ------------------
  108|  4.31k|		m_RawData = (uint8_t*)pRawData;
  109|  4.31k|		m_RawDataLen = rawDataLen;
  110|  4.31k|		m_TimeStamp = timestamp;
  111|  4.31k|		m_RawPacketSet = true;
  112|  4.31k|		m_LinkLayerType = layerType;
  113|  4.31k|		return true;
  114|  4.31k|	}
_ZN4pcpp9RawPacket5clearEv:
  123|  5.01k|	{
  124|  5.01k|		if (m_RawData != nullptr && m_OwnsRawData)
  ------------------
  |  Branch (124:7): [True: 3.04k, False: 1.97k]
  |  Branch (124:31): [True: 3.04k, False: 0]
  ------------------
  125|  3.04k|			delete[] m_RawData;
  126|       |
  127|  5.01k|		m_RawData = nullptr;
  128|  5.01k|		m_RawDataLen = 0;
  129|  5.01k|		m_FrameLength = 0;
  130|  5.01k|		m_RawPacketSet = false;
  131|  5.01k|	}

_ZN4pcpp15createGreaseSetEv:
 1041|      2|	{
 1042|      2|		uint16_t greaseExtensions[] = { 0x0a0a, 0x1a1a, 0x2a2a, 0x3a3a, 0x4a4a, 0x5a5a, 0x6a6a, 0x7a7a,
 1043|      2|			                            0x8a8a, 0x9a9a, 0xaaaa, 0xbaba, 0xcaca, 0xdada, 0xeaea, 0xfafa };
 1044|      2|		return std::set<uint16_t>(greaseExtensions, greaseExtensions + 16);
 1045|      2|	}
SSLHandshake.cpp:_ZN4pcppL30createCipherSuiteIdToObjectMapEv:
  353|      2|	{
  354|      2|		std::unordered_map<uint16_t, SSLCipherSuite*> result;
  355|       |
  356|      2|		result[0x0000] = (SSLCipherSuite*)&Cipher1;
  357|      2|		result[0x0001] = (SSLCipherSuite*)&Cipher2;
  358|      2|		result[0x0002] = (SSLCipherSuite*)&Cipher3;
  359|      2|		result[0x0003] = (SSLCipherSuite*)&Cipher4;
  360|      2|		result[0x0004] = (SSLCipherSuite*)&Cipher5;
  361|      2|		result[0x0005] = (SSLCipherSuite*)&Cipher6;
  362|      2|		result[0x0006] = (SSLCipherSuite*)&Cipher7;
  363|      2|		result[0x0007] = (SSLCipherSuite*)&Cipher8;
  364|      2|		result[0x0008] = (SSLCipherSuite*)&Cipher9;
  365|      2|		result[0x0009] = (SSLCipherSuite*)&Cipher10;
  366|      2|		result[0x000A] = (SSLCipherSuite*)&Cipher11;
  367|      2|		result[0x000B] = (SSLCipherSuite*)&Cipher12;
  368|      2|		result[0x000C] = (SSLCipherSuite*)&Cipher13;
  369|      2|		result[0x000D] = (SSLCipherSuite*)&Cipher14;
  370|      2|		result[0x000E] = (SSLCipherSuite*)&Cipher15;
  371|      2|		result[0x000F] = (SSLCipherSuite*)&Cipher16;
  372|      2|		result[0x0010] = (SSLCipherSuite*)&Cipher17;
  373|      2|		result[0x0011] = (SSLCipherSuite*)&Cipher18;
  374|      2|		result[0x0012] = (SSLCipherSuite*)&Cipher19;
  375|      2|		result[0x0013] = (SSLCipherSuite*)&Cipher20;
  376|      2|		result[0x0014] = (SSLCipherSuite*)&Cipher21;
  377|      2|		result[0x0015] = (SSLCipherSuite*)&Cipher22;
  378|      2|		result[0x0016] = (SSLCipherSuite*)&Cipher23;
  379|      2|		result[0x0017] = (SSLCipherSuite*)&Cipher24;
  380|      2|		result[0x0018] = (SSLCipherSuite*)&Cipher25;
  381|      2|		result[0x0019] = (SSLCipherSuite*)&Cipher26;
  382|      2|		result[0x001A] = (SSLCipherSuite*)&Cipher27;
  383|      2|		result[0x001B] = (SSLCipherSuite*)&Cipher28;
  384|      2|		result[0x001E] = (SSLCipherSuite*)&Cipher29;
  385|      2|		result[0x001F] = (SSLCipherSuite*)&Cipher30;
  386|      2|		result[0x0020] = (SSLCipherSuite*)&Cipher31;
  387|      2|		result[0x0021] = (SSLCipherSuite*)&Cipher32;
  388|      2|		result[0x0022] = (SSLCipherSuite*)&Cipher33;
  389|      2|		result[0x0023] = (SSLCipherSuite*)&Cipher34;
  390|      2|		result[0x0024] = (SSLCipherSuite*)&Cipher35;
  391|      2|		result[0x0025] = (SSLCipherSuite*)&Cipher36;
  392|      2|		result[0x0026] = (SSLCipherSuite*)&Cipher37;
  393|      2|		result[0x0027] = (SSLCipherSuite*)&Cipher38;
  394|      2|		result[0x0028] = (SSLCipherSuite*)&Cipher39;
  395|      2|		result[0x0029] = (SSLCipherSuite*)&Cipher40;
  396|      2|		result[0x002A] = (SSLCipherSuite*)&Cipher41;
  397|      2|		result[0x002B] = (SSLCipherSuite*)&Cipher42;
  398|      2|		result[0x002C] = (SSLCipherSuite*)&Cipher43;
  399|      2|		result[0x002D] = (SSLCipherSuite*)&Cipher44;
  400|      2|		result[0x002E] = (SSLCipherSuite*)&Cipher45;
  401|      2|		result[0x002F] = (SSLCipherSuite*)&Cipher46;
  402|      2|		result[0x0030] = (SSLCipherSuite*)&Cipher47;
  403|      2|		result[0x0031] = (SSLCipherSuite*)&Cipher48;
  404|      2|		result[0x0032] = (SSLCipherSuite*)&Cipher49;
  405|      2|		result[0x0033] = (SSLCipherSuite*)&Cipher50;
  406|      2|		result[0x0034] = (SSLCipherSuite*)&Cipher51;
  407|      2|		result[0x0035] = (SSLCipherSuite*)&Cipher52;
  408|      2|		result[0x0036] = (SSLCipherSuite*)&Cipher53;
  409|      2|		result[0x0037] = (SSLCipherSuite*)&Cipher54;
  410|      2|		result[0x0038] = (SSLCipherSuite*)&Cipher55;
  411|      2|		result[0x0039] = (SSLCipherSuite*)&Cipher56;
  412|      2|		result[0x003A] = (SSLCipherSuite*)&Cipher57;
  413|      2|		result[0x003B] = (SSLCipherSuite*)&Cipher58;
  414|      2|		result[0x003C] = (SSLCipherSuite*)&Cipher59;
  415|      2|		result[0x003D] = (SSLCipherSuite*)&Cipher60;
  416|      2|		result[0x003E] = (SSLCipherSuite*)&Cipher61;
  417|      2|		result[0x003F] = (SSLCipherSuite*)&Cipher62;
  418|      2|		result[0x0040] = (SSLCipherSuite*)&Cipher63;
  419|      2|		result[0x0041] = (SSLCipherSuite*)&Cipher64;
  420|      2|		result[0x0042] = (SSLCipherSuite*)&Cipher65;
  421|      2|		result[0x0043] = (SSLCipherSuite*)&Cipher66;
  422|      2|		result[0x0044] = (SSLCipherSuite*)&Cipher67;
  423|      2|		result[0x0045] = (SSLCipherSuite*)&Cipher68;
  424|      2|		result[0x0046] = (SSLCipherSuite*)&Cipher69;
  425|      2|		result[0x0067] = (SSLCipherSuite*)&Cipher70;
  426|      2|		result[0x0068] = (SSLCipherSuite*)&Cipher71;
  427|      2|		result[0x0069] = (SSLCipherSuite*)&Cipher72;
  428|      2|		result[0x006A] = (SSLCipherSuite*)&Cipher73;
  429|      2|		result[0x006B] = (SSLCipherSuite*)&Cipher74;
  430|      2|		result[0x006C] = (SSLCipherSuite*)&Cipher75;
  431|      2|		result[0x006D] = (SSLCipherSuite*)&Cipher76;
  432|      2|		result[0x0084] = (SSLCipherSuite*)&Cipher77;
  433|      2|		result[0x0085] = (SSLCipherSuite*)&Cipher78;
  434|      2|		result[0x0086] = (SSLCipherSuite*)&Cipher79;
  435|      2|		result[0x0087] = (SSLCipherSuite*)&Cipher80;
  436|      2|		result[0x0088] = (SSLCipherSuite*)&Cipher81;
  437|      2|		result[0x0089] = (SSLCipherSuite*)&Cipher82;
  438|      2|		result[0x008A] = (SSLCipherSuite*)&Cipher83;
  439|      2|		result[0x008B] = (SSLCipherSuite*)&Cipher84;
  440|      2|		result[0x008C] = (SSLCipherSuite*)&Cipher85;
  441|      2|		result[0x008D] = (SSLCipherSuite*)&Cipher86;
  442|      2|		result[0x008E] = (SSLCipherSuite*)&Cipher87;
  443|      2|		result[0x008F] = (SSLCipherSuite*)&Cipher88;
  444|      2|		result[0x0090] = (SSLCipherSuite*)&Cipher89;
  445|      2|		result[0x0091] = (SSLCipherSuite*)&Cipher90;
  446|      2|		result[0x0092] = (SSLCipherSuite*)&Cipher91;
  447|      2|		result[0x0093] = (SSLCipherSuite*)&Cipher92;
  448|      2|		result[0x0094] = (SSLCipherSuite*)&Cipher93;
  449|      2|		result[0x0095] = (SSLCipherSuite*)&Cipher94;
  450|      2|		result[0x0096] = (SSLCipherSuite*)&Cipher95;
  451|      2|		result[0x0097] = (SSLCipherSuite*)&Cipher96;
  452|      2|		result[0x0098] = (SSLCipherSuite*)&Cipher97;
  453|      2|		result[0x0099] = (SSLCipherSuite*)&Cipher98;
  454|      2|		result[0x009A] = (SSLCipherSuite*)&Cipher99;
  455|      2|		result[0x009B] = (SSLCipherSuite*)&Cipher100;
  456|      2|		result[0x009C] = (SSLCipherSuite*)&Cipher101;
  457|      2|		result[0x009D] = (SSLCipherSuite*)&Cipher102;
  458|      2|		result[0x009E] = (SSLCipherSuite*)&Cipher103;
  459|      2|		result[0x009F] = (SSLCipherSuite*)&Cipher104;
  460|      2|		result[0x00A0] = (SSLCipherSuite*)&Cipher105;
  461|      2|		result[0x00A1] = (SSLCipherSuite*)&Cipher106;
  462|      2|		result[0x00A2] = (SSLCipherSuite*)&Cipher107;
  463|      2|		result[0x00A3] = (SSLCipherSuite*)&Cipher108;
  464|      2|		result[0x00A4] = (SSLCipherSuite*)&Cipher109;
  465|      2|		result[0x00A5] = (SSLCipherSuite*)&Cipher110;
  466|      2|		result[0x00A6] = (SSLCipherSuite*)&Cipher111;
  467|      2|		result[0x00A7] = (SSLCipherSuite*)&Cipher112;
  468|      2|		result[0x00A8] = (SSLCipherSuite*)&Cipher113;
  469|      2|		result[0x00A9] = (SSLCipherSuite*)&Cipher114;
  470|      2|		result[0x00AA] = (SSLCipherSuite*)&Cipher115;
  471|      2|		result[0x00AB] = (SSLCipherSuite*)&Cipher116;
  472|      2|		result[0x00AC] = (SSLCipherSuite*)&Cipher117;
  473|      2|		result[0x00AD] = (SSLCipherSuite*)&Cipher118;
  474|      2|		result[0x00AE] = (SSLCipherSuite*)&Cipher119;
  475|      2|		result[0x00AF] = (SSLCipherSuite*)&Cipher120;
  476|      2|		result[0x00B0] = (SSLCipherSuite*)&Cipher121;
  477|      2|		result[0x00B1] = (SSLCipherSuite*)&Cipher122;
  478|      2|		result[0x00B2] = (SSLCipherSuite*)&Cipher123;
  479|      2|		result[0x00B3] = (SSLCipherSuite*)&Cipher124;
  480|      2|		result[0x00B4] = (SSLCipherSuite*)&Cipher125;
  481|      2|		result[0x00B5] = (SSLCipherSuite*)&Cipher126;
  482|      2|		result[0x00B6] = (SSLCipherSuite*)&Cipher127;
  483|      2|		result[0x00B7] = (SSLCipherSuite*)&Cipher128;
  484|      2|		result[0x00B8] = (SSLCipherSuite*)&Cipher129;
  485|      2|		result[0x00B9] = (SSLCipherSuite*)&Cipher130;
  486|      2|		result[0x00BA] = (SSLCipherSuite*)&Cipher131;
  487|      2|		result[0x00BB] = (SSLCipherSuite*)&Cipher132;
  488|      2|		result[0x00BC] = (SSLCipherSuite*)&Cipher133;
  489|      2|		result[0x00BD] = (SSLCipherSuite*)&Cipher134;
  490|      2|		result[0x00BE] = (SSLCipherSuite*)&Cipher135;
  491|      2|		result[0x00BF] = (SSLCipherSuite*)&Cipher136;
  492|      2|		result[0x00C0] = (SSLCipherSuite*)&Cipher137;
  493|      2|		result[0x00C1] = (SSLCipherSuite*)&Cipher138;
  494|      2|		result[0x00C2] = (SSLCipherSuite*)&Cipher139;
  495|      2|		result[0x00C3] = (SSLCipherSuite*)&Cipher140;
  496|      2|		result[0x00C4] = (SSLCipherSuite*)&Cipher141;
  497|      2|		result[0x00C5] = (SSLCipherSuite*)&Cipher142;
  498|      2|		result[0xC001] = (SSLCipherSuite*)&Cipher143;
  499|      2|		result[0xC002] = (SSLCipherSuite*)&Cipher144;
  500|      2|		result[0xC003] = (SSLCipherSuite*)&Cipher145;
  501|      2|		result[0xC004] = (SSLCipherSuite*)&Cipher146;
  502|      2|		result[0xC005] = (SSLCipherSuite*)&Cipher147;
  503|      2|		result[0xC006] = (SSLCipherSuite*)&Cipher148;
  504|      2|		result[0xC007] = (SSLCipherSuite*)&Cipher149;
  505|      2|		result[0xC008] = (SSLCipherSuite*)&Cipher150;
  506|      2|		result[0xC009] = (SSLCipherSuite*)&Cipher151;
  507|      2|		result[0xC00A] = (SSLCipherSuite*)&Cipher152;
  508|      2|		result[0xC00B] = (SSLCipherSuite*)&Cipher153;
  509|      2|		result[0xC00C] = (SSLCipherSuite*)&Cipher154;
  510|      2|		result[0xC00D] = (SSLCipherSuite*)&Cipher155;
  511|      2|		result[0xC00E] = (SSLCipherSuite*)&Cipher156;
  512|      2|		result[0xC00F] = (SSLCipherSuite*)&Cipher157;
  513|      2|		result[0xC010] = (SSLCipherSuite*)&Cipher158;
  514|      2|		result[0xC011] = (SSLCipherSuite*)&Cipher159;
  515|      2|		result[0xC012] = (SSLCipherSuite*)&Cipher160;
  516|      2|		result[0xC013] = (SSLCipherSuite*)&Cipher161;
  517|      2|		result[0xC014] = (SSLCipherSuite*)&Cipher162;
  518|      2|		result[0xC015] = (SSLCipherSuite*)&Cipher163;
  519|      2|		result[0xC016] = (SSLCipherSuite*)&Cipher164;
  520|      2|		result[0xC017] = (SSLCipherSuite*)&Cipher165;
  521|      2|		result[0xC018] = (SSLCipherSuite*)&Cipher166;
  522|      2|		result[0xC019] = (SSLCipherSuite*)&Cipher167;
  523|      2|		result[0xC01A] = (SSLCipherSuite*)&Cipher168;
  524|      2|		result[0xC01B] = (SSLCipherSuite*)&Cipher169;
  525|      2|		result[0xC01C] = (SSLCipherSuite*)&Cipher170;
  526|      2|		result[0xC01D] = (SSLCipherSuite*)&Cipher171;
  527|      2|		result[0xC01E] = (SSLCipherSuite*)&Cipher172;
  528|      2|		result[0xC01F] = (SSLCipherSuite*)&Cipher173;
  529|      2|		result[0xC020] = (SSLCipherSuite*)&Cipher174;
  530|      2|		result[0xC021] = (SSLCipherSuite*)&Cipher175;
  531|      2|		result[0xC022] = (SSLCipherSuite*)&Cipher176;
  532|      2|		result[0xC023] = (SSLCipherSuite*)&Cipher177;
  533|      2|		result[0xC024] = (SSLCipherSuite*)&Cipher178;
  534|      2|		result[0xC025] = (SSLCipherSuite*)&Cipher179;
  535|      2|		result[0xC026] = (SSLCipherSuite*)&Cipher180;
  536|      2|		result[0xC027] = (SSLCipherSuite*)&Cipher181;
  537|      2|		result[0xC028] = (SSLCipherSuite*)&Cipher182;
  538|      2|		result[0xC029] = (SSLCipherSuite*)&Cipher183;
  539|      2|		result[0xC02A] = (SSLCipherSuite*)&Cipher184;
  540|      2|		result[0xC02B] = (SSLCipherSuite*)&Cipher185;
  541|      2|		result[0xC02C] = (SSLCipherSuite*)&Cipher186;
  542|      2|		result[0xC02D] = (SSLCipherSuite*)&Cipher187;
  543|      2|		result[0xC02E] = (SSLCipherSuite*)&Cipher188;
  544|      2|		result[0xC02F] = (SSLCipherSuite*)&Cipher189;
  545|      2|		result[0xC030] = (SSLCipherSuite*)&Cipher190;
  546|      2|		result[0xC031] = (SSLCipherSuite*)&Cipher191;
  547|      2|		result[0xC032] = (SSLCipherSuite*)&Cipher192;
  548|      2|		result[0xC033] = (SSLCipherSuite*)&Cipher193;
  549|      2|		result[0xC034] = (SSLCipherSuite*)&Cipher194;
  550|      2|		result[0xC035] = (SSLCipherSuite*)&Cipher195;
  551|      2|		result[0xC036] = (SSLCipherSuite*)&Cipher196;
  552|      2|		result[0xC037] = (SSLCipherSuite*)&Cipher197;
  553|      2|		result[0xC038] = (SSLCipherSuite*)&Cipher198;
  554|      2|		result[0xC039] = (SSLCipherSuite*)&Cipher199;
  555|      2|		result[0xC03A] = (SSLCipherSuite*)&Cipher200;
  556|      2|		result[0xC03B] = (SSLCipherSuite*)&Cipher201;
  557|      2|		result[0xC03C] = (SSLCipherSuite*)&Cipher202;
  558|      2|		result[0xC03D] = (SSLCipherSuite*)&Cipher203;
  559|      2|		result[0xC03E] = (SSLCipherSuite*)&Cipher204;
  560|      2|		result[0xC03F] = (SSLCipherSuite*)&Cipher205;
  561|      2|		result[0xC040] = (SSLCipherSuite*)&Cipher206;
  562|      2|		result[0xC041] = (SSLCipherSuite*)&Cipher207;
  563|      2|		result[0xC042] = (SSLCipherSuite*)&Cipher208;
  564|      2|		result[0xC043] = (SSLCipherSuite*)&Cipher209;
  565|      2|		result[0xC044] = (SSLCipherSuite*)&Cipher210;
  566|      2|		result[0xC045] = (SSLCipherSuite*)&Cipher211;
  567|      2|		result[0xC046] = (SSLCipherSuite*)&Cipher212;
  568|      2|		result[0xC047] = (SSLCipherSuite*)&Cipher213;
  569|      2|		result[0xC048] = (SSLCipherSuite*)&Cipher214;
  570|      2|		result[0xC049] = (SSLCipherSuite*)&Cipher215;
  571|      2|		result[0xC04A] = (SSLCipherSuite*)&Cipher216;
  572|      2|		result[0xC04B] = (SSLCipherSuite*)&Cipher217;
  573|      2|		result[0xC04C] = (SSLCipherSuite*)&Cipher218;
  574|      2|		result[0xC04D] = (SSLCipherSuite*)&Cipher219;
  575|      2|		result[0xC04E] = (SSLCipherSuite*)&Cipher220;
  576|      2|		result[0xC04F] = (SSLCipherSuite*)&Cipher221;
  577|      2|		result[0xC050] = (SSLCipherSuite*)&Cipher222;
  578|      2|		result[0xC051] = (SSLCipherSuite*)&Cipher223;
  579|      2|		result[0xC052] = (SSLCipherSuite*)&Cipher224;
  580|      2|		result[0xC053] = (SSLCipherSuite*)&Cipher225;
  581|      2|		result[0xC054] = (SSLCipherSuite*)&Cipher226;
  582|      2|		result[0xC055] = (SSLCipherSuite*)&Cipher227;
  583|      2|		result[0xC056] = (SSLCipherSuite*)&Cipher228;
  584|      2|		result[0xC057] = (SSLCipherSuite*)&Cipher229;
  585|      2|		result[0xC058] = (SSLCipherSuite*)&Cipher230;
  586|      2|		result[0xC059] = (SSLCipherSuite*)&Cipher231;
  587|      2|		result[0xC05A] = (SSLCipherSuite*)&Cipher232;
  588|      2|		result[0xC05B] = (SSLCipherSuite*)&Cipher233;
  589|      2|		result[0xC05C] = (SSLCipherSuite*)&Cipher234;
  590|      2|		result[0xC05D] = (SSLCipherSuite*)&Cipher235;
  591|      2|		result[0xC05E] = (SSLCipherSuite*)&Cipher236;
  592|      2|		result[0xC05F] = (SSLCipherSuite*)&Cipher237;
  593|      2|		result[0xC060] = (SSLCipherSuite*)&Cipher238;
  594|      2|		result[0xC061] = (SSLCipherSuite*)&Cipher239;
  595|      2|		result[0xC062] = (SSLCipherSuite*)&Cipher240;
  596|      2|		result[0xC063] = (SSLCipherSuite*)&Cipher241;
  597|      2|		result[0xC064] = (SSLCipherSuite*)&Cipher242;
  598|      2|		result[0xC065] = (SSLCipherSuite*)&Cipher243;
  599|      2|		result[0xC066] = (SSLCipherSuite*)&Cipher244;
  600|      2|		result[0xC067] = (SSLCipherSuite*)&Cipher245;
  601|      2|		result[0xC068] = (SSLCipherSuite*)&Cipher246;
  602|      2|		result[0xC069] = (SSLCipherSuite*)&Cipher247;
  603|      2|		result[0xC06A] = (SSLCipherSuite*)&Cipher248;
  604|      2|		result[0xC06B] = (SSLCipherSuite*)&Cipher249;
  605|      2|		result[0xC06C] = (SSLCipherSuite*)&Cipher250;
  606|      2|		result[0xC06D] = (SSLCipherSuite*)&Cipher251;
  607|      2|		result[0xC06E] = (SSLCipherSuite*)&Cipher252;
  608|      2|		result[0xC06F] = (SSLCipherSuite*)&Cipher253;
  609|      2|		result[0xC070] = (SSLCipherSuite*)&Cipher254;
  610|      2|		result[0xC071] = (SSLCipherSuite*)&Cipher255;
  611|      2|		result[0xC072] = (SSLCipherSuite*)&Cipher256;
  612|      2|		result[0xC073] = (SSLCipherSuite*)&Cipher257;
  613|      2|		result[0xC074] = (SSLCipherSuite*)&Cipher258;
  614|      2|		result[0xC075] = (SSLCipherSuite*)&Cipher259;
  615|      2|		result[0xC076] = (SSLCipherSuite*)&Cipher260;
  616|      2|		result[0xC077] = (SSLCipherSuite*)&Cipher261;
  617|      2|		result[0xC078] = (SSLCipherSuite*)&Cipher262;
  618|      2|		result[0xC079] = (SSLCipherSuite*)&Cipher263;
  619|      2|		result[0xC07A] = (SSLCipherSuite*)&Cipher264;
  620|      2|		result[0xC07B] = (SSLCipherSuite*)&Cipher265;
  621|      2|		result[0xC07C] = (SSLCipherSuite*)&Cipher266;
  622|      2|		result[0xC07D] = (SSLCipherSuite*)&Cipher267;
  623|      2|		result[0xC07E] = (SSLCipherSuite*)&Cipher268;
  624|      2|		result[0xC07F] = (SSLCipherSuite*)&Cipher269;
  625|      2|		result[0xC080] = (SSLCipherSuite*)&Cipher270;
  626|      2|		result[0xC081] = (SSLCipherSuite*)&Cipher271;
  627|      2|		result[0xC082] = (SSLCipherSuite*)&Cipher272;
  628|      2|		result[0xC083] = (SSLCipherSuite*)&Cipher273;
  629|      2|		result[0xC084] = (SSLCipherSuite*)&Cipher274;
  630|      2|		result[0xC085] = (SSLCipherSuite*)&Cipher275;
  631|      2|		result[0xC086] = (SSLCipherSuite*)&Cipher276;
  632|      2|		result[0xC087] = (SSLCipherSuite*)&Cipher277;
  633|      2|		result[0xC088] = (SSLCipherSuite*)&Cipher278;
  634|      2|		result[0xC089] = (SSLCipherSuite*)&Cipher279;
  635|      2|		result[0xC08A] = (SSLCipherSuite*)&Cipher280;
  636|      2|		result[0xC08B] = (SSLCipherSuite*)&Cipher281;
  637|      2|		result[0xC08C] = (SSLCipherSuite*)&Cipher282;
  638|      2|		result[0xC08D] = (SSLCipherSuite*)&Cipher283;
  639|      2|		result[0xC08E] = (SSLCipherSuite*)&Cipher284;
  640|      2|		result[0xC08F] = (SSLCipherSuite*)&Cipher285;
  641|      2|		result[0xC090] = (SSLCipherSuite*)&Cipher286;
  642|      2|		result[0xC091] = (SSLCipherSuite*)&Cipher287;
  643|      2|		result[0xC092] = (SSLCipherSuite*)&Cipher288;
  644|      2|		result[0xC093] = (SSLCipherSuite*)&Cipher289;
  645|      2|		result[0xC094] = (SSLCipherSuite*)&Cipher290;
  646|      2|		result[0xC095] = (SSLCipherSuite*)&Cipher291;
  647|      2|		result[0xC096] = (SSLCipherSuite*)&Cipher292;
  648|      2|		result[0xC097] = (SSLCipherSuite*)&Cipher293;
  649|      2|		result[0xC098] = (SSLCipherSuite*)&Cipher294;
  650|      2|		result[0xC099] = (SSLCipherSuite*)&Cipher295;
  651|      2|		result[0xC09A] = (SSLCipherSuite*)&Cipher296;
  652|      2|		result[0xC09B] = (SSLCipherSuite*)&Cipher297;
  653|      2|		result[0xC09C] = (SSLCipherSuite*)&Cipher298;
  654|      2|		result[0xC09D] = (SSLCipherSuite*)&Cipher299;
  655|      2|		result[0xC09E] = (SSLCipherSuite*)&Cipher300;
  656|      2|		result[0xC09F] = (SSLCipherSuite*)&Cipher301;
  657|      2|		result[0xC0A0] = (SSLCipherSuite*)&Cipher302;
  658|      2|		result[0xC0A1] = (SSLCipherSuite*)&Cipher303;
  659|      2|		result[0xC0A2] = (SSLCipherSuite*)&Cipher304;
  660|      2|		result[0xC0A3] = (SSLCipherSuite*)&Cipher305;
  661|      2|		result[0xC0A4] = (SSLCipherSuite*)&Cipher306;
  662|      2|		result[0xC0A5] = (SSLCipherSuite*)&Cipher307;
  663|      2|		result[0xC0A6] = (SSLCipherSuite*)&Cipher308;
  664|      2|		result[0xC0A7] = (SSLCipherSuite*)&Cipher309;
  665|      2|		result[0xC0A8] = (SSLCipherSuite*)&Cipher310;
  666|      2|		result[0xC0A9] = (SSLCipherSuite*)&Cipher311;
  667|      2|		result[0xC0AA] = (SSLCipherSuite*)&Cipher312;
  668|      2|		result[0xC0AB] = (SSLCipherSuite*)&Cipher313;
  669|      2|		result[0xC0AC] = (SSLCipherSuite*)&Cipher314;
  670|      2|		result[0xC0AD] = (SSLCipherSuite*)&Cipher315;
  671|      2|		result[0xC0AE] = (SSLCipherSuite*)&Cipher316;
  672|      2|		result[0xC0AF] = (SSLCipherSuite*)&Cipher317;
  673|      2|		result[0xCCA8] = (SSLCipherSuite*)&Cipher318;
  674|      2|		result[0xCCA9] = (SSLCipherSuite*)&Cipher319;
  675|      2|		result[0xCCAA] = (SSLCipherSuite*)&Cipher320;
  676|      2|		result[0xCCAB] = (SSLCipherSuite*)&Cipher321;
  677|      2|		result[0xCCAC] = (SSLCipherSuite*)&Cipher322;
  678|      2|		result[0xCCAD] = (SSLCipherSuite*)&Cipher323;
  679|      2|		result[0xCCAE] = (SSLCipherSuite*)&Cipher324;
  680|      2|		result[0x1301] = (SSLCipherSuite*)&Cipher325;
  681|      2|		result[0x1302] = (SSLCipherSuite*)&Cipher326;
  682|      2|		result[0x1303] = (SSLCipherSuite*)&Cipher327;
  683|      2|		result[0x1304] = (SSLCipherSuite*)&Cipher328;
  684|      2|		result[0x1305] = (SSLCipherSuite*)&Cipher329;
  685|      2|		return result;
  686|      2|	}
SSLHandshake.cpp:_ZN4pcppL34createCipherSuiteStringToObjectMapEv:
  704|      2|	{
  705|      2|		std::unordered_map<uint32_t, SSLCipherSuite*> result;
  706|       |
  707|      2|		result[0x9F180F43] = (SSLCipherSuite*)&Cipher1;
  708|      2|		result[0x97D9341F] = (SSLCipherSuite*)&Cipher2;
  709|      2|		result[0x288FABA1] = (SSLCipherSuite*)&Cipher3;
  710|      2|		result[0x9179C5BD] = (SSLCipherSuite*)&Cipher4;
  711|      2|		result[0x68DF0C8F] = (SSLCipherSuite*)&Cipher5;
  712|      2|		result[0x5FB32DF1] = (SSLCipherSuite*)&Cipher6;
  713|      2|		result[0x2A1FC0FC] = (SSLCipherSuite*)&Cipher7;
  714|      2|		result[0x5BF6459E] = (SSLCipherSuite*)&Cipher8;
  715|      2|		result[0x60D692F4] = (SSLCipherSuite*)&Cipher9;
  716|      2|		result[0x26A21427] = (SSLCipherSuite*)&Cipher10;
  717|      2|		result[0xD3558C6D] = (SSLCipherSuite*)&Cipher11;
  718|      2|		result[0xAE2673E9] = (SSLCipherSuite*)&Cipher12;
  719|      2|		result[0xC63B19B0] = (SSLCipherSuite*)&Cipher13;
  720|      2|		result[0xFE49B3BC] = (SSLCipherSuite*)&Cipher14;
  721|      2|		result[0x625A86D5] = (SSLCipherSuite*)&Cipher15;
  722|      2|		result[0x60FF1BD4] = (SSLCipherSuite*)&Cipher16;
  723|      2|		result[0xE101D5C8] = (SSLCipherSuite*)&Cipher17;
  724|      2|		result[0x422859E8] = (SSLCipherSuite*)&Cipher18;
  725|      2|		result[0x88ABC503] = (SSLCipherSuite*)&Cipher19;
  726|      2|		result[0x44284B1] = (SSLCipherSuite*)&Cipher20;
  727|      2|		result[0xFD71B064] = (SSLCipherSuite*)&Cipher21;
  728|      2|		result[0x76F35237] = (SSLCipherSuite*)&Cipher22;
  729|      2|		result[0x7D93159D] = (SSLCipherSuite*)&Cipher23;
  730|      2|		result[0x6E9D1AE2] = (SSLCipherSuite*)&Cipher24;
  731|      2|		result[0xFA0974E4] = (SSLCipherSuite*)&Cipher25;
  732|      2|		result[0xEC27ACB1] = (SSLCipherSuite*)&Cipher26;
  733|      2|		result[0x6859C7A8] = (SSLCipherSuite*)&Cipher27;
  734|      2|		result[0x55FD3D14] = (SSLCipherSuite*)&Cipher28;
  735|      2|		result[0xA7650023] = (SSLCipherSuite*)&Cipher29;
  736|      2|		result[0xDC042011] = (SSLCipherSuite*)&Cipher30;
  737|      2|		result[0x94BFBF4D] = (SSLCipherSuite*)&Cipher31;
  738|      2|		result[0x2FE24162] = (SSLCipherSuite*)&Cipher32;
  739|      2|		result[0xC449D595] = (SSLCipherSuite*)&Cipher33;
  740|      2|		result[0xE11292AF] = (SSLCipherSuite*)&Cipher34;
  741|      2|		result[0x47D0643] = (SSLCipherSuite*)&Cipher35;
  742|      2|		result[0xC9ABBA3C] = (SSLCipherSuite*)&Cipher36;
  743|      2|		result[0x9F323A5F] = (SSLCipherSuite*)&Cipher37;
  744|      2|		result[0xFBF78046] = (SSLCipherSuite*)&Cipher38;
  745|      2|		result[0x859BD79F] = (SSLCipherSuite*)&Cipher39;
  746|      2|		result[0xF9FBBB39] = (SSLCipherSuite*)&Cipher40;
  747|      2|		result[0x63587748] = (SSLCipherSuite*)&Cipher41;
  748|      2|		result[0xF84CAE79] = (SSLCipherSuite*)&Cipher42;
  749|      2|		result[0xCA39F6F1] = (SSLCipherSuite*)&Cipher43;
  750|      2|		result[0xDC4D17C1] = (SSLCipherSuite*)&Cipher44;
  751|      2|		result[0x955FBE28] = (SSLCipherSuite*)&Cipher45;
  752|      2|		result[0x73ED7B86] = (SSLCipherSuite*)&Cipher46;
  753|      2|		result[0x14A51855] = (SSLCipherSuite*)&Cipher47;
  754|      2|		result[0x2CE54061] = (SSLCipherSuite*)&Cipher48;
  755|      2|		result[0x3360789A] = (SSLCipherSuite*)&Cipher49;
  756|      2|		result[0xDFEF59B6] = (SSLCipherSuite*)&Cipher50;
  757|      2|		result[0xE819855D] = (SSLCipherSuite*)&Cipher51;
  758|      2|		result[0x24CC3946] = (SSLCipherSuite*)&Cipher52;
  759|      2|		result[0x1CACB5FD] = (SSLCipherSuite*)&Cipher53;
  760|      2|		result[0x40193001] = (SSLCipherSuite*)&Cipher54;
  761|      2|		result[0xA3846DA2] = (SSLCipherSuite*)&Cipher55;
  762|      2|		result[0x8F3B7CF6] = (SSLCipherSuite*)&Cipher56;
  763|      2|		result[0xC7B09945] = (SSLCipherSuite*)&Cipher57;
  764|      2|		result[0xD8172F82] = (SSLCipherSuite*)&Cipher58;
  765|      2|		result[0xB6748503] = (SSLCipherSuite*)&Cipher59;
  766|      2|		result[0xDB105043] = (SSLCipherSuite*)&Cipher60;
  767|      2|		result[0x21E8AC2E] = (SSLCipherSuite*)&Cipher61;
  768|      2|		result[0x55096FC2] = (SSLCipherSuite*)&Cipher62;
  769|      2|		result[0x38F955AF] = (SSLCipherSuite*)&Cipher63;
  770|      2|		result[0xBA8C1D77] = (SSLCipherSuite*)&Cipher64;
  771|      2|		result[0x91128102] = (SSLCipherSuite*)&Cipher65;
  772|      2|		result[0xA7ED740E] = (SSLCipherSuite*)&Cipher66;
  773|      2|		result[0x75C4908B] = (SSLCipherSuite*)&Cipher67;
  774|      2|		result[0xBC6C5E87] = (SSLCipherSuite*)&Cipher68;
  775|      2|		result[0xA0499A2A] = (SSLCipherSuite*)&Cipher69;
  776|      2|		result[0x4F0FFC13] = (SSLCipherSuite*)&Cipher70;
  777|      2|		result[0xCCEE9996] = (SSLCipherSuite*)&Cipher71;
  778|      2|		result[0x8570DA22] = (SSLCipherSuite*)&Cipher72;
  779|      2|		result[0x75D4FD57] = (SSLCipherSuite*)&Cipher73;
  780|      2|		result[0x602E04D3] = (SSLCipherSuite*)&Cipher74;
  781|      2|		result[0x5EDC9C36] = (SSLCipherSuite*)&Cipher75;
  782|      2|		result[0xE66C167E] = (SSLCipherSuite*)&Cipher76;
  783|      2|		result[0x909F6D7B] = (SSLCipherSuite*)&Cipher77;
  784|      2|		result[0x3C35B1AA] = (SSLCipherSuite*)&Cipher78;
  785|      2|		result[0x6D4D1A2E] = (SSLCipherSuite*)&Cipher79;
  786|      2|		result[0xBF788317] = (SSLCipherSuite*)&Cipher80;
  787|      2|		result[0x5329738B] = (SSLCipherSuite*)&Cipher81;
  788|      2|		result[0x7D11AB2] = (SSLCipherSuite*)&Cipher82;
  789|      2|		result[0x461ACA21] = (SSLCipherSuite*)&Cipher83;
  790|      2|		result[0x15404ADD] = (SSLCipherSuite*)&Cipher84;
  791|      2|		result[0x3806AF6] = (SSLCipherSuite*)&Cipher85;
  792|      2|		result[0xB2D80EB6] = (SSLCipherSuite*)&Cipher86;
  793|      2|		result[0xE54425D1] = (SSLCipherSuite*)&Cipher87;
  794|      2|		result[0x476457CD] = (SSLCipherSuite*)&Cipher88;
  795|      2|		result[0x1D55E526] = (SSLCipherSuite*)&Cipher89;
  796|      2|		result[0x953C69E6] = (SSLCipherSuite*)&Cipher90;
  797|      2|		result[0x6ADE7E16] = (SSLCipherSuite*)&Cipher91;
  798|      2|		result[0xE8C7BBE8] = (SSLCipherSuite*)&Cipher92;
  799|      2|		result[0x623DC741] = (SSLCipherSuite*)&Cipher93;
  800|      2|		result[0xF403E1] = (SSLCipherSuite*)&Cipher94;
  801|      2|		result[0x90D8CADC] = (SSLCipherSuite*)&Cipher95;
  802|      2|		result[0xC30D1199] = (SSLCipherSuite*)&Cipher96;
  803|      2|		result[0x9CFB1B5D] = (SSLCipherSuite*)&Cipher97;
  804|      2|		result[0x2D3B99E8] = (SSLCipherSuite*)&Cipher98;
  805|      2|		result[0x4A9E8B0C] = (SSLCipherSuite*)&Cipher99;
  806|      2|		result[0x16BD2351] = (SSLCipherSuite*)&Cipher100;
  807|      2|		result[0x586BC20E] = (SSLCipherSuite*)&Cipher101;
  808|      2|		result[0x996B90AA] = (SSLCipherSuite*)&Cipher102;
  809|      2|		result[0x2F3871FE] = (SSLCipherSuite*)&Cipher103;
  810|      2|		result[0xF2DD519A] = (SSLCipherSuite*)&Cipher104;
  811|      2|		result[0x52615F23] = (SSLCipherSuite*)&Cipher105;
  812|      2|		result[0xDEE51337] = (SSLCipherSuite*)&Cipher106;
  813|      2|		result[0xB30890E2] = (SSLCipherSuite*)&Cipher107;
  814|      2|		result[0x40F3FF3E] = (SSLCipherSuite*)&Cipher108;
  815|      2|		result[0xE306EE17] = (SSLCipherSuite*)&Cipher109;
  816|      2|		result[0x870C6FCB] = (SSLCipherSuite*)&Cipher110;
  817|      2|		result[0xEB12CAEF] = (SSLCipherSuite*)&Cipher111;
  818|      2|		result[0x68795983] = (SSLCipherSuite*)&Cipher112;
  819|      2|		result[0x606BA9BE] = (SSLCipherSuite*)&Cipher113;
  820|      2|		result[0x2C33475A] = (SSLCipherSuite*)&Cipher114;
  821|      2|		result[0x640CAAEE] = (SSLCipherSuite*)&Cipher115;
  822|      2|		result[0x6603488A] = (SSLCipherSuite*)&Cipher116;
  823|      2|		result[0x8BA58643] = (SSLCipherSuite*)&Cipher117;
  824|      2|		result[0x16059E57] = (SSLCipherSuite*)&Cipher118;
  825|      2|		result[0x1B0606D3] = (SSLCipherSuite*)&Cipher119;
  826|      2|		result[0x1CF76007] = (SSLCipherSuite*)&Cipher120;
  827|      2|		result[0x618CE8F2] = (SSLCipherSuite*)&Cipher121;
  828|      2|		result[0xE264D3B6] = (SSLCipherSuite*)&Cipher122;
  829|      2|		result[0xB4C5AE63] = (SSLCipherSuite*)&Cipher123;
  830|      2|		result[0x95DF4757] = (SSLCipherSuite*)&Cipher124;
  831|      2|		result[0x1D1CF062] = (SSLCipherSuite*)&Cipher125;
  832|      2|		result[0xE7AA2826] = (SSLCipherSuite*)&Cipher126;
  833|      2|		result[0x38D94EE2] = (SSLCipherSuite*)&Cipher127;
  834|      2|		result[0x889BA306] = (SSLCipherSuite*)&Cipher128;
  835|      2|		result[0x5B816E75] = (SSLCipherSuite*)&Cipher129;
  836|      2|		result[0x6F18C4DD] = (SSLCipherSuite*)&Cipher130;
  837|      2|		result[0x2E1C05E0] = (SSLCipherSuite*)&Cipher131;
  838|      2|		result[0x5592CFF7] = (SSLCipherSuite*)&Cipher132;
  839|      2|		result[0x8221D38B] = (SSLCipherSuite*)&Cipher133;
  840|      2|		result[0x9538105C] = (SSLCipherSuite*)&Cipher134;
  841|      2|		result[0xF1100DD0] = (SSLCipherSuite*)&Cipher135;
  842|      2|		result[0xF492EF1F] = (SSLCipherSuite*)&Cipher136;
  843|      2|		result[0x226BD52C] = (SSLCipherSuite*)&Cipher137;
  844|      2|		result[0xBBACE99F] = (SSLCipherSuite*)&Cipher138;
  845|      2|		result[0xB3D4B66B] = (SSLCipherSuite*)&Cipher139;
  846|      2|		result[0x8C619440] = (SSLCipherSuite*)&Cipher140;
  847|      2|		result[0xE60B95C] = (SSLCipherSuite*)&Cipher141;
  848|      2|		result[0x24F48D07] = (SSLCipherSuite*)&Cipher142;
  849|      2|		result[0x15C7AF26] = (SSLCipherSuite*)&Cipher143;
  850|      2|		result[0xCBA219CC] = (SSLCipherSuite*)&Cipher144;
  851|      2|		result[0x9BD946BE] = (SSLCipherSuite*)&Cipher145;
  852|      2|		result[0x7CCA46FF] = (SSLCipherSuite*)&Cipher146;
  853|      2|		result[0x9FB51FA3] = (SSLCipherSuite*)&Cipher147;
  854|      2|		result[0xC82A275B] = (SSLCipherSuite*)&Cipher148;
  855|      2|		result[0x4472A583] = (SSLCipherSuite*)&Cipher149;
  856|      2|		result[0xDBA3A5CF] = (SSLCipherSuite*)&Cipher150;
  857|      2|		result[0x86338128] = (SSLCipherSuite*)&Cipher151;
  858|      2|		result[0x8CCE91E4] = (SSLCipherSuite*)&Cipher152;
  859|      2|		result[0xA81C6CA0] = (SSLCipherSuite*)&Cipher153;
  860|      2|		result[0x6D80815E] = (SSLCipherSuite*)&Cipher154;
  861|      2|		result[0xA383DEB0] = (SSLCipherSuite*)&Cipher155;
  862|      2|		result[0x52073879] = (SSLCipherSuite*)&Cipher156;
  863|      2|		result[0x5BA0B279] = (SSLCipherSuite*)&Cipher157;
  864|      2|		result[0xD787CCC9] = (SSLCipherSuite*)&Cipher158;
  865|      2|		result[0x9C86C6A9] = (SSLCipherSuite*)&Cipher159;
  866|      2|		result[0xDAE424E5] = (SSLCipherSuite*)&Cipher160;
  867|      2|		result[0x72C15ECE] = (SSLCipherSuite*)&Cipher161;
  868|      2|		result[0xF0E8FB6E] = (SSLCipherSuite*)&Cipher162;
  869|      2|		result[0xA2005D44] = (SSLCipherSuite*)&Cipher163;
  870|      2|		result[0x77F79962] = (SSLCipherSuite*)&Cipher164;
  871|      2|		result[0x25C8184C] = (SSLCipherSuite*)&Cipher165;
  872|      2|		result[0x2070F8A5] = (SSLCipherSuite*)&Cipher166;
  873|      2|		result[0x4189ED8D] = (SSLCipherSuite*)&Cipher167;
  874|      2|		result[0x94C21B1] = (SSLCipherSuite*)&Cipher168;
  875|      2|		result[0x1B0CB25C] = (SSLCipherSuite*)&Cipher169;
  876|      2|		result[0xF18127A0] = (SSLCipherSuite*)&Cipher170;
  877|      2|		result[0xC7FCA79A] = (SSLCipherSuite*)&Cipher171;
  878|      2|		result[0xC1DEE135] = (SSLCipherSuite*)&Cipher172;
  879|      2|		result[0xDA7143E9] = (SSLCipherSuite*)&Cipher173;
  880|      2|		result[0xE82B6A2] = (SSLCipherSuite*)&Cipher174;
  881|      2|		result[0x438EC1DD] = (SSLCipherSuite*)&Cipher175;
  882|      2|		result[0x6BE32FA9] = (SSLCipherSuite*)&Cipher176;
  883|      2|		result[0x18A5C375] = (SSLCipherSuite*)&Cipher177;
  884|      2|		result[0x24136C59] = (SSLCipherSuite*)&Cipher178;
  885|      2|		result[0x88529408] = (SSLCipherSuite*)&Cipher179;
  886|      2|		result[0xADAB33FC] = (SSLCipherSuite*)&Cipher180;
  887|      2|		result[0x79407DCB] = (SSLCipherSuite*)&Cipher181;
  888|      2|		result[0x64970FFF] = (SSLCipherSuite*)&Cipher182;
  889|      2|		result[0x8260DC9A] = (SSLCipherSuite*)&Cipher183;
  890|      2|		result[0x4B74FFFE] = (SSLCipherSuite*)&Cipher184;
  891|      2|		result[0x350DD5C8] = (SSLCipherSuite*)&Cipher185;
  892|      2|		result[0x53E057C] = (SSLCipherSuite*)&Cipher186;
  893|      2|		result[0x266020E1] = (SSLCipherSuite*)&Cipher187;
  894|      2|		result[0xE6DB4B9D] = (SSLCipherSuite*)&Cipher188;
  895|      2|		result[0x5A992E6] = (SSLCipherSuite*)&Cipher189;
  896|      2|		result[0x1B33C882] = (SSLCipherSuite*)&Cipher190;
  897|      2|		result[0x33579D2B] = (SSLCipherSuite*)&Cipher191;
  898|      2|		result[0x1BD7F7FF] = (SSLCipherSuite*)&Cipher192;
  899|      2|		result[0x39C59ED9] = (SSLCipherSuite*)&Cipher193;
  900|      2|		result[0x4F19FB95] = (SSLCipherSuite*)&Cipher194;
  901|      2|		result[0x8F4737BE] = (SSLCipherSuite*)&Cipher195;
  902|      2|		result[0x2567AA9E] = (SSLCipherSuite*)&Cipher196;
  903|      2|		result[0xEEF843DB] = (SSLCipherSuite*)&Cipher197;
  904|      2|		result[0x978C4E4F] = (SSLCipherSuite*)&Cipher198;
  905|      2|		result[0x2F8D17D9] = (SSLCipherSuite*)&Cipher199;
  906|      2|		result[0x7F80393A] = (SSLCipherSuite*)&Cipher200;
  907|      2|		result[0xDCA5AE1E] = (SSLCipherSuite*)&Cipher201;
  908|      2|		result[0x74AA95D7] = (SSLCipherSuite*)&Cipher202;
  909|      2|		result[0xB93174BB] = (SSLCipherSuite*)&Cipher203;
  910|      2|		result[0x46E274FC] = (SSLCipherSuite*)&Cipher204;
  911|      2|		result[0x9DC85330] = (SSLCipherSuite*)&Cipher205;
  912|      2|		result[0x972847B8] = (SSLCipherSuite*)&Cipher206;
  913|      2|		result[0xFCF61DAC] = (SSLCipherSuite*)&Cipher207;
  914|      2|		result[0x73C0029B] = (SSLCipherSuite*)&Cipher208;
  915|      2|		result[0xDA41D70F] = (SSLCipherSuite*)&Cipher209;
  916|      2|		result[0x12CBC4E7] = (SSLCipherSuite*)&Cipher210;
  917|      2|		result[0x8B2D5ACB] = (SSLCipherSuite*)&Cipher211;
  918|      2|		result[0x28C0C084] = (SSLCipherSuite*)&Cipher212;
  919|      2|		result[0x1602C1F8] = (SSLCipherSuite*)&Cipher213;
  920|      2|		result[0xF5FB9ED] = (SSLCipherSuite*)&Cipher214;
  921|      2|		result[0xE8E30E91] = (SSLCipherSuite*)&Cipher215;
  922|      2|		result[0x70BA7792] = (SSLCipherSuite*)&Cipher216;
  923|      2|		result[0x94C38076] = (SSLCipherSuite*)&Cipher217;
  924|      2|		result[0xE5B3483F] = (SSLCipherSuite*)&Cipher218;
  925|      2|		result[0x892DEBE3] = (SSLCipherSuite*)&Cipher219;
  926|      2|		result[0x65609E50] = (SSLCipherSuite*)&Cipher220;
  927|      2|		result[0xAB4F3F04] = (SSLCipherSuite*)&Cipher221;
  928|      2|		result[0x8BFC76DA] = (SSLCipherSuite*)&Cipher222;
  929|      2|		result[0xD4BDCD6] = (SSLCipherSuite*)&Cipher223;
  930|      2|		result[0xCAB8F54A] = (SSLCipherSuite*)&Cipher224;
  931|      2|		result[0xA10DCFC6] = (SSLCipherSuite*)&Cipher225;
  932|      2|		result[0xD6B71B71] = (SSLCipherSuite*)&Cipher226;
  933|      2|		result[0x6D775A2D] = (SSLCipherSuite*)&Cipher227;
  934|      2|		result[0x7997AD16] = (SSLCipherSuite*)&Cipher228;
  935|      2|		result[0x5338C632] = (SSLCipherSuite*)&Cipher229;
  936|      2|		result[0x45F0598D] = (SSLCipherSuite*)&Cipher230;
  937|      2|		result[0x2D8B6A99] = (SSLCipherSuite*)&Cipher231;
  938|      2|		result[0xE14DC125] = (SSLCipherSuite*)&Cipher232;
  939|      2|		result[0x1538351] = (SSLCipherSuite*)&Cipher233;
  940|      2|		result[0x1A8CE530] = (SSLCipherSuite*)&Cipher234;
  941|      2|		result[0xB01E69C4] = (SSLCipherSuite*)&Cipher235;
  942|      2|		result[0xCCBF70D3] = (SSLCipherSuite*)&Cipher236;
  943|      2|		result[0xEF664FE7] = (SSLCipherSuite*)&Cipher237;
  944|      2|		result[0xF6ED4F52] = (SSLCipherSuite*)&Cipher238;
  945|      2|		result[0x7D6522E] = (SSLCipherSuite*)&Cipher239;
  946|      2|		result[0xBDB5C9B9] = (SSLCipherSuite*)&Cipher240;
  947|      2|		result[0xD98D5C95] = (SSLCipherSuite*)&Cipher241;
  948|      2|		result[0x92B92727] = (SSLCipherSuite*)&Cipher242;
  949|      2|		result[0xB4FE570B] = (SSLCipherSuite*)&Cipher243;
  950|      2|		result[0x8DCF7F77] = (SSLCipherSuite*)&Cipher244;
  951|      2|		result[0x8208545B] = (SSLCipherSuite*)&Cipher245;
  952|      2|		result[0x39A13298] = (SSLCipherSuite*)&Cipher246;
  953|      2|		result[0xECB7070C] = (SSLCipherSuite*)&Cipher247;
  954|      2|		result[0xAFA95F8A] = (SSLCipherSuite*)&Cipher248;
  955|      2|		result[0x3D80E106] = (SSLCipherSuite*)&Cipher249;
  956|      2|		result[0x83AF9B7A] = (SSLCipherSuite*)&Cipher250;
  957|      2|		result[0x1FAAC2F6] = (SSLCipherSuite*)&Cipher251;
  958|      2|		result[0x2AF11F51] = (SSLCipherSuite*)&Cipher252;
  959|      2|		result[0xEDFD300D] = (SSLCipherSuite*)&Cipher253;
  960|      2|		result[0x91AA268F] = (SSLCipherSuite*)&Cipher254;
  961|      2|		result[0x9DF0E933] = (SSLCipherSuite*)&Cipher255;
  962|      2|		result[0xF3951A6A] = (SSLCipherSuite*)&Cipher256;
  963|      2|		result[0xE4FF8DCE] = (SSLCipherSuite*)&Cipher257;
  964|      2|		result[0xBE4DFC61] = (SSLCipherSuite*)&Cipher258;
  965|      2|		result[0xBB2CF025] = (SSLCipherSuite*)&Cipher259;
  966|      2|		result[0x354D38A8] = (SSLCipherSuite*)&Cipher260;
  967|      2|		result[0xE2444B9C] = (SSLCipherSuite*)&Cipher261;
  968|      2|		result[0xF8298D43] = (SSLCipherSuite*)&Cipher262;
  969|      2|		result[0x3EC413B7] = (SSLCipherSuite*)&Cipher263;
  970|      2|		result[0xE0C75BE9] = (SSLCipherSuite*)&Cipher264;
  971|      2|		result[0x7191BE45] = (SSLCipherSuite*)&Cipher265;
  972|      2|		result[0xDDE7C439] = (SSLCipherSuite*)&Cipher266;
  973|      2|		result[0xBE715415] = (SSLCipherSuite*)&Cipher267;
  974|      2|		result[0x6CF8F9A6] = (SSLCipherSuite*)&Cipher268;
  975|      2|		result[0x36D61242] = (SSLCipherSuite*)&Cipher269;
  976|      2|		result[0xFA9BA9ED] = (SSLCipherSuite*)&Cipher270;
  977|      2|		result[0x4588B179] = (SSLCipherSuite*)&Cipher271;
  978|      2|		result[0xB3C246FA] = (SSLCipherSuite*)&Cipher272;
  979|      2|		result[0x750EEB76] = (SSLCipherSuite*)&Cipher273;
  980|      2|		result[0xC50ACCB2] = (SSLCipherSuite*)&Cipher274;
  981|      2|		result[0x9555CD0E] = (SSLCipherSuite*)&Cipher275;
  982|      2|		result[0xF25A659B] = (SSLCipherSuite*)&Cipher276;
  983|      2|		result[0x1670E72F] = (SSLCipherSuite*)&Cipher277;
  984|      2|		result[0xDB0DD6BC] = (SSLCipherSuite*)&Cipher278;
  985|      2|		result[0x19CACD70] = (SSLCipherSuite*)&Cipher279;
  986|      2|		result[0xC54D5481] = (SSLCipherSuite*)&Cipher280;
  987|      2|		result[0x7BCCA2BD] = (SSLCipherSuite*)&Cipher281;
  988|      2|		result[0xA851374E] = (SSLCipherSuite*)&Cipher282;
  989|      2|		result[0xE887BEA] = (SSLCipherSuite*)&Cipher283;
  990|      2|		result[0xDECAA7F9] = (SSLCipherSuite*)&Cipher284;
  991|      2|		result[0x29DA73D5] = (SSLCipherSuite*)&Cipher285;
  992|      2|		result[0xAC69ECC9] = (SSLCipherSuite*)&Cipher286;
  993|      2|		result[0x6AE55625] = (SSLCipherSuite*)&Cipher287;
  994|      2|		result[0x2BB24546] = (SSLCipherSuite*)&Cipher288;
  995|      2|		result[0x7AB5F262] = (SSLCipherSuite*)&Cipher289;
  996|      2|		result[0x3DB83990] = (SSLCipherSuite*)&Cipher290;
  997|      2|		result[0xC852A244] = (SSLCipherSuite*)&Cipher291;
  998|      2|		result[0xA3C952C0] = (SSLCipherSuite*)&Cipher292;
  999|      2|		result[0xAF630C34] = (SSLCipherSuite*)&Cipher293;
 1000|      2|		result[0xD4EE22B] = (SSLCipherSuite*)&Cipher294;
 1001|      2|		result[0x83F4C5DF] = (SSLCipherSuite*)&Cipher295;
 1002|      2|		result[0xCCF6F918] = (SSLCipherSuite*)&Cipher296;
 1003|      2|		result[0x955C9E8C] = (SSLCipherSuite*)&Cipher297;
 1004|      2|		result[0xF3559154] = (SSLCipherSuite*)&Cipher298;
 1005|      2|		result[0xE0991C14] = (SSLCipherSuite*)&Cipher299;
 1006|      2|		result[0x7F6BF424] = (SSLCipherSuite*)&Cipher300;
 1007|      2|		result[0x4A129264] = (SSLCipherSuite*)&Cipher301;
 1008|      2|		result[0xB25E29E3] = (SSLCipherSuite*)&Cipher302;
 1009|      2|		result[0xA6E15A23] = (SSLCipherSuite*)&Cipher303;
 1010|      2|		result[0x637C5C53] = (SSLCipherSuite*)&Cipher304;
 1011|      2|		result[0x22794513] = (SSLCipherSuite*)&Cipher305;
 1012|      2|		result[0x4CE30464] = (SSLCipherSuite*)&Cipher306;
 1013|      2|		result[0xFDFE3B24] = (SSLCipherSuite*)&Cipher307;
 1014|      2|		result[0xDC8A2074] = (SSLCipherSuite*)&Cipher308;
 1015|      2|		result[0xFD448934] = (SSLCipherSuite*)&Cipher309;
 1016|      2|		result[0xF4FC2B13] = (SSLCipherSuite*)&Cipher310;
 1017|      2|		result[0xB10ECD53] = (SSLCipherSuite*)&Cipher311;
 1018|      2|		result[0xF44F4BC7] = (SSLCipherSuite*)&Cipher312;
 1019|      2|		result[0x49AF0BF] = (SSLCipherSuite*)&Cipher313;
 1020|      2|		result[0xDFAF479A] = (SSLCipherSuite*)&Cipher314;
 1021|      2|		result[0x82BF78CE] = (SSLCipherSuite*)&Cipher315;
 1022|      2|		result[0x46CD83C9] = (SSLCipherSuite*)&Cipher316;
 1023|      2|		result[0x8F7D7465] = (SSLCipherSuite*)&Cipher317;
 1024|      2|		result[0xBD9CDFE5] = (SSLCipherSuite*)&Cipher318;
 1025|      2|		result[0x92942203] = (SSLCipherSuite*)&Cipher319;
 1026|      2|		result[0x783C98AD] = (SSLCipherSuite*)&Cipher320;
 1027|      2|		result[0x92213B6D] = (SSLCipherSuite*)&Cipher321;
 1028|      2|		result[0xCFCB1A55] = (SSLCipherSuite*)&Cipher322;
 1029|      2|		result[0x54C2D55D] = (SSLCipherSuite*)&Cipher323;
 1030|      2|		result[0xDCD6F114] = (SSLCipherSuite*)&Cipher324;
 1031|      2|		result[0x6AD23C40] = (SSLCipherSuite*)&Cipher325;
 1032|      2|		result[0x5F5239D4] = (SSLCipherSuite*)&Cipher326;
 1033|      2|		result[0xAB27704B] = (SSLCipherSuite*)&Cipher327;
 1034|      2|		result[0xA3178D0C] = (SSLCipherSuite*)&Cipher328;
 1035|      2|		result[0x5DAAA195] = (SSLCipherSuite*)&Cipher329;
 1036|       |
 1037|      2|		return result;
 1038|      2|	}

_ZN4pcpp7IDeviceD2Ev:
   26|  1.48k|		virtual ~IDevice() = default;
_ZN4pcpp17IFilterableDeviceC2Ev:
   47|  1.48k|		IFilterableDevice() = default;
_ZN4pcpp7IDeviceC2Ev:
   23|  1.48k|		IDevice() = default;

_ZN4pcpp23IPcapStatisticsProviderD2Ev:
   27|  1.48k|		virtual ~IPcapStatisticsProvider() = default;

_ZN4pcpp22PcapNgFileWriterDeviceD2Ev:
  455|    701|		{
  456|    701|			PcapNgFileWriterDevice::close();
  457|    701|		}
_ZN4pcpp11IFileDevice21reportPacketProcessedEm:
   66|  8.63k|		{
   67|  8.63k|			m_NumOfPacketsProcessed += numPackets;
   68|  8.63k|		}
_ZN4pcpp20PcapFileReaderDeviceC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  174|    781|		explicit PcapFileReaderDevice(const std::string& fileName) : IFileReaderDevice(fileName)
  175|    781|		{}
_ZN4pcpp20PcapFileReaderDeviceD2Ev:
  178|    781|		~PcapFileReaderDevice() override = default;

_ZN4pcpp16BpfFilterWrapperC2Ev:
   93|  1.48k|		BpfFilterWrapper() = default;

_ZN4pcpp11IFileDeviceC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  494|  1.48k|	{
  495|  1.48k|		m_FileName = fileName;
  496|  1.48k|	}
_ZNK4pcpp11IFileDevice13getStatisticsERNS_9PcapStatsE:
  504|    355|	{
  505|    355|		PCPP_LOG_DEBUG("Statistics requested for file device for filename '" << m_FileName << "'");
  ------------------
  |  |  426|    355|#	define PCPP_LOG_DEBUG(message) PCPP_LOG(pcpp::LogLevel::Debug, message)
  |  |  ------------------
  |  |  |  |  413|    355|	do                                                                                                                 \
  |  |  |  |  414|    355|	{                                                                                                                  \
  |  |  |  |  415|    355|		auto& logger = pcpp::Logger::getInstance();                                                                    \
  |  |  |  |  416|    355|		if (logger.shouldLog(level, LOG_MODULE))                                                                       \
  |  |  |  |  ------------------
  |  |  |  |  |  |    3|    355|#define LOG_MODULE PcapLogModuleFileDevice
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (416:7): [True: 0, False: 355]
  |  |  |  |  ------------------
  |  |  |  |  417|    355|		{                                                                                                              \
  |  |  |  |  418|      0|			auto ctx =                                                                                                 \
  |  |  |  |  419|      0|			    logger.createLogContext(level, pcpp::LogSource(LOG_MODULE, PCAPPP_FILENAME, __FUNCTION__, __LINE__));  \
  |  |  |  |  ------------------
  |  |  |  |  |  |    3|      0|#define LOG_MODULE PcapLogModuleFileDevice
  |  |  |  |  ------------------
  |  |  |  |               			    logger.createLogContext(level, pcpp::LogSource(LOG_MODULE, PCAPPP_FILENAME, __FUNCTION__, __LINE__));  \
  |  |  |  |  ------------------
  |  |  |  |  |  |   20|       |#	define PCAPPP_FILENAME __FILE_NAME__
  |  |  |  |  ------------------
  |  |  |  |  420|      0|			(*ctx) << message;                                                                                         \
  |  |  |  |  421|      0|			logger.emit(std::move(ctx));                                                                               \
  |  |  |  |  422|      0|		}                                                                                                              \
  |  |  |  |  423|    355|	} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (423:11): [Folded, False: 355]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  506|    355|		stats.packetsRecv = m_NumOfPacketsProcessed;
  507|    355|		stats.packetsDrop = m_NumOfPacketsDropped;
  508|    355|		stats.packetsDropByInterface = 0;
  509|    355|	}
_ZN4pcpp11IFileDevice22resetStatisticCountersEv:
  512|  1.48k|	{
  513|  1.48k|		m_NumOfPacketsProcessed = 0;
  514|  1.48k|		m_NumOfPacketsDropped = 0;
  515|  1.48k|	}
_ZN4pcpp17IFileReaderDeviceC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  531|    781|	IFileReaderDevice::IFileReaderDevice(const std::string& fileName) : IFileDevice(fileName)
  532|    781|	{}
_ZN4pcpp17IFileReaderDevice9getReaderERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  535|    781|	{
  536|    781|		const auto extensionPos = fileName.find_last_of('.');
  537|    781|		const auto fileExtension = extensionPos != std::string::npos ? fileName.substr(extensionPos) : "";
  ------------------
  |  Branch (537:30): [True: 781, False: 0]
  ------------------
  538|       |
  539|    781|		if (fileExtension == ".pcapng" || fileExtension == ".zstd" || fileExtension == ".zst")
  ------------------
  |  Branch (539:7): [True: 0, False: 781]
  |  Branch (539:37): [True: 0, False: 781]
  |  Branch (539:65): [True: 0, False: 781]
  ------------------
  540|      0|			return new PcapNgFileReaderDevice(fileName);
  541|    781|		else if (fileExtension == ".snoop")
  ------------------
  |  Branch (541:12): [True: 0, False: 781]
  ------------------
  542|      0|			return new SnoopFileReaderDevice(fileName);
  543|       |
  544|    781|		return new PcapFileReaderDevice(fileName);
  545|    781|	}
_ZN4pcpp17IFileReaderDevice14getNextPacketsERNS_13PointerVectorINS_9RawPacketENSt3__114default_deleteIS2_EEEEi:
  606|    701|	{
  607|    701|		int numOfPacketsRead = 0;
  608|       |
  609|  1.05k|		for (; numOfPacketsToRead < 0 || numOfPacketsRead < numOfPacketsToRead; numOfPacketsRead++)
  ------------------
  |  Branch (609:10): [True: 0, False: 1.05k]
  |  Branch (609:36): [True: 701, False: 355]
  ------------------
  610|    701|		{
  611|    701|			RawPacket* newPacket = new RawPacket();
  612|    701|			bool packetRead = getNextPacket(*newPacket);
  613|    701|			if (packetRead)
  ------------------
  |  Branch (613:8): [True: 355, False: 346]
  ------------------
  614|    355|			{
  615|    355|				packetVec.pushBack(newPacket);
  616|    355|			}
  617|    346|			else
  618|    346|			{
  619|    346|				delete newPacket;
  620|    346|				break;
  621|    346|			}
  622|    701|		}
  623|       |
  624|    701|		return numOfPacketsRead;
  625|    701|	}
_ZN4pcpp17IFileWriterDeviceC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  631|    701|	IFileWriterDevice::IFileWriterDevice(const std::string& fileName) : IFileDevice(fileName)
  632|    701|	{}
_ZN4pcpp20PcapFileReaderDevice4openEv:
  709|    781|	{
  710|    781|		if (m_PcapFile.is_open())
  ------------------
  |  Branch (710:7): [True: 0, False: 781]
  ------------------
  711|      0|		{
  712|      0|			PCPP_LOG_ERROR("File already opened");
  ------------------
  |  |  444|      0|#	define PCPP_LOG_ERROR(message) PCPP_LOG(pcpp::LogLevel::Error, message)
  |  |  ------------------
  |  |  |  |  413|      0|	do                                                                                                                 \
  |  |  |  |  414|      0|	{                                                                                                                  \
  |  |  |  |  415|      0|		auto& logger = pcpp::Logger::getInstance();                                                                    \
  |  |  |  |  416|      0|		if (logger.shouldLog(level, LOG_MODULE))                                                                       \
  |  |  |  |  ------------------
  |  |  |  |  |  |    3|      0|#define LOG_MODULE PcapLogModuleFileDevice
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (416:7): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  417|      0|		{                                                                                                              \
  |  |  |  |  418|      0|			auto ctx =                                                                                                 \
  |  |  |  |  419|      0|			    logger.createLogContext(level, pcpp::LogSource(LOG_MODULE, PCAPPP_FILENAME, __FUNCTION__, __LINE__));  \
  |  |  |  |  ------------------
  |  |  |  |  |  |    3|      0|#define LOG_MODULE PcapLogModuleFileDevice
  |  |  |  |  ------------------
  |  |  |  |               			    logger.createLogContext(level, pcpp::LogSource(LOG_MODULE, PCAPPP_FILENAME, __FUNCTION__, __LINE__));  \
  |  |  |  |  ------------------
  |  |  |  |  |  |   20|       |#	define PCAPPP_FILENAME __FILE_NAME__
  |  |  |  |  ------------------
  |  |  |  |  420|      0|			(*ctx) << message;                                                                                         \
  |  |  |  |  421|      0|			logger.emit(std::move(ctx));                                                                               \
  |  |  |  |  422|      0|		}                                                                                                              \
  |  |  |  |  423|      0|	} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (423:11): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  713|      0|			return false;
  714|      0|		}
  715|       |
  716|    781|		resetStatisticCounters();
  717|       |
  718|    781|		std::ifstream pcapFile;
  719|    781|		pcapFile.open(m_FileName.c_str(), std::ifstream::binary);
  720|    781|		if (!pcapFile.is_open())
  ------------------
  |  Branch (720:7): [True: 0, False: 781]
  ------------------
  721|      0|		{
  722|      0|			PCPP_LOG_ERROR("Cannot open pcap reader device for filename '" << m_FileName << "'");
  ------------------
  |  |  444|      0|#	define PCPP_LOG_ERROR(message) PCPP_LOG(pcpp::LogLevel::Error, message)
  |  |  ------------------
  |  |  |  |  413|      0|	do                                                                                                                 \
  |  |  |  |  414|      0|	{                                                                                                                  \
  |  |  |  |  415|      0|		auto& logger = pcpp::Logger::getInstance();                                                                    \
  |  |  |  |  416|      0|		if (logger.shouldLog(level, LOG_MODULE))                                                                       \
  |  |  |  |  ------------------
  |  |  |  |  |  |    3|      0|#define LOG_MODULE PcapLogModuleFileDevice
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (416:7): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  417|      0|		{                                                                                                              \
  |  |  |  |  418|      0|			auto ctx =                                                                                                 \
  |  |  |  |  419|      0|			    logger.createLogContext(level, pcpp::LogSource(LOG_MODULE, PCAPPP_FILENAME, __FUNCTION__, __LINE__));  \
  |  |  |  |  ------------------
  |  |  |  |  |  |    3|      0|#define LOG_MODULE PcapLogModuleFileDevice
  |  |  |  |  ------------------
  |  |  |  |               			    logger.createLogContext(level, pcpp::LogSource(LOG_MODULE, PCAPPP_FILENAME, __FUNCTION__, __LINE__));  \
  |  |  |  |  ------------------
  |  |  |  |  |  |   20|       |#	define PCAPPP_FILENAME __FILE_NAME__
  |  |  |  |  ------------------
  |  |  |  |  420|      0|			(*ctx) << message;                                                                                         \
  |  |  |  |  421|      0|			logger.emit(std::move(ctx));                                                                               \
  |  |  |  |  422|      0|		}                                                                                                              \
  |  |  |  |  423|      0|	} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (423:11): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  723|      0|			return false;
  724|      0|		}
  725|       |
  726|    781|		pcap_file_header pcapFileHeader{};
  727|    781|		auto status = readPcapHeader(pcapFile, pcapFileHeader, m_Precision, m_NeedsSwap);
  728|    781|		switch (status)
  729|    781|		{
  730|    767|		case PcapReadHeaderStatus::Ok:
  ------------------
  |  Branch (730:3): [True: 767, False: 14]
  ------------------
  731|    767|			break;
  732|      0|		case PcapReadHeaderStatus::NoData:
  ------------------
  |  Branch (732:3): [True: 0, False: 781]
  ------------------
  733|     10|		case PcapReadHeaderStatus::MalformedData:
  ------------------
  |  Branch (733:3): [True: 10, False: 771]
  ------------------
  734|     10|		{
  735|     10|			PCPP_LOG_ERROR("Cannot read pcap file header");
  ------------------
  |  |  444|     10|#	define PCPP_LOG_ERROR(message) PCPP_LOG(pcpp::LogLevel::Error, message)
  |  |  ------------------
  |  |  |  |  413|     10|	do                                                                                                                 \
  |  |  |  |  414|     10|	{                                                                                                                  \
  |  |  |  |  415|     10|		auto& logger = pcpp::Logger::getInstance();                                                                    \
  |  |  |  |  416|     10|		if (logger.shouldLog(level, LOG_MODULE))                                                                       \
  |  |  |  |  ------------------
  |  |  |  |  |  |    3|     10|#define LOG_MODULE PcapLogModuleFileDevice
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (416:7): [True: 10, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  417|     10|		{                                                                                                              \
  |  |  |  |  418|     10|			auto ctx =                                                                                                 \
  |  |  |  |  419|     10|			    logger.createLogContext(level, pcpp::LogSource(LOG_MODULE, PCAPPP_FILENAME, __FUNCTION__, __LINE__));  \
  |  |  |  |  ------------------
  |  |  |  |  |  |    3|     10|#define LOG_MODULE PcapLogModuleFileDevice
  |  |  |  |  ------------------
  |  |  |  |               			    logger.createLogContext(level, pcpp::LogSource(LOG_MODULE, PCAPPP_FILENAME, __FUNCTION__, __LINE__));  \
  |  |  |  |  ------------------
  |  |  |  |  |  |   20|       |#	define PCAPPP_FILENAME __FILE_NAME__
  |  |  |  |  ------------------
  |  |  |  |  420|     10|			(*ctx) << message;                                                                                         \
  |  |  |  |  421|     10|			logger.emit(std::move(ctx));                                                                               \
  |  |  |  |  422|     10|		}                                                                                                              \
  |  |  |  |  423|     10|	} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (423:11): [Folded, False: 10]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  736|     10|			return false;
  737|      0|		}
  738|      4|		case PcapReadHeaderStatus::UnsupportedFormat:
  ------------------
  |  Branch (738:3): [True: 4, False: 777]
  ------------------
  739|      4|		{
  740|      4|			PCPP_LOG_ERROR("File content is not pcap or byte order can't be determined. Detected magic number: 0x"
  ------------------
  |  |  444|      4|#	define PCPP_LOG_ERROR(message) PCPP_LOG(pcpp::LogLevel::Error, message)
  |  |  ------------------
  |  |  |  |  413|      4|	do                                                                                                                 \
  |  |  |  |  414|      4|	{                                                                                                                  \
  |  |  |  |  415|      4|		auto& logger = pcpp::Logger::getInstance();                                                                    \
  |  |  |  |  416|      4|		if (logger.shouldLog(level, LOG_MODULE))                                                                       \
  |  |  |  |  ------------------
  |  |  |  |  |  |    3|      4|#define LOG_MODULE PcapLogModuleFileDevice
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (416:7): [True: 4, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  417|      4|		{                                                                                                              \
  |  |  |  |  418|      4|			auto ctx =                                                                                                 \
  |  |  |  |  419|      4|			    logger.createLogContext(level, pcpp::LogSource(LOG_MODULE, PCAPPP_FILENAME, __FUNCTION__, __LINE__));  \
  |  |  |  |  ------------------
  |  |  |  |  |  |    3|      4|#define LOG_MODULE PcapLogModuleFileDevice
  |  |  |  |  ------------------
  |  |  |  |               			    logger.createLogContext(level, pcpp::LogSource(LOG_MODULE, PCAPPP_FILENAME, __FUNCTION__, __LINE__));  \
  |  |  |  |  ------------------
  |  |  |  |  |  |   20|       |#	define PCAPPP_FILENAME __FILE_NAME__
  |  |  |  |  ------------------
  |  |  |  |  420|      4|			(*ctx) << message;                                                                                         \
  |  |  |  |  421|      4|			logger.emit(std::move(ctx));                                                                               \
  |  |  |  |  422|      4|		}                                                                                                              \
  |  |  |  |  423|      4|	} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (423:11): [Folded, False: 4]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  741|      4|			               << std::hex << pcapFileHeader.magic);
  742|      4|			return false;
  743|      0|		}
  744|      0|		default:
  ------------------
  |  Branch (744:3): [True: 0, False: 781]
  ------------------
  745|      0|			throw std::logic_error("Unhandled PcapReadHeaderStatus value");
  746|    781|		}
  747|       |
  748|    767|		if (pcapFileHeader.version_major != 2 && pcapFileHeader.version_major != 543)
  ------------------
  |  Branch (748:7): [True: 28, False: 739]
  |  Branch (748:44): [True: 26, False: 2]
  ------------------
  749|     26|		{
  750|     26|			PCPP_LOG_ERROR("Unsupported pcap file version: " << std::to_string(pcapFileHeader.version_major) << "."
  ------------------
  |  |  444|     26|#	define PCPP_LOG_ERROR(message) PCPP_LOG(pcpp::LogLevel::Error, message)
  |  |  ------------------
  |  |  |  |  413|     26|	do                                                                                                                 \
  |  |  |  |  414|     26|	{                                                                                                                  \
  |  |  |  |  415|     26|		auto& logger = pcpp::Logger::getInstance();                                                                    \
  |  |  |  |  416|     26|		if (logger.shouldLog(level, LOG_MODULE))                                                                       \
  |  |  |  |  ------------------
  |  |  |  |  |  |    3|     26|#define LOG_MODULE PcapLogModuleFileDevice
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (416:7): [True: 26, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  417|     26|		{                                                                                                              \
  |  |  |  |  418|     26|			auto ctx =                                                                                                 \
  |  |  |  |  419|     26|			    logger.createLogContext(level, pcpp::LogSource(LOG_MODULE, PCAPPP_FILENAME, __FUNCTION__, __LINE__));  \
  |  |  |  |  ------------------
  |  |  |  |  |  |    3|     26|#define LOG_MODULE PcapLogModuleFileDevice
  |  |  |  |  ------------------
  |  |  |  |               			    logger.createLogContext(level, pcpp::LogSource(LOG_MODULE, PCAPPP_FILENAME, __FUNCTION__, __LINE__));  \
  |  |  |  |  ------------------
  |  |  |  |  |  |   20|       |#	define PCAPPP_FILENAME __FILE_NAME__
  |  |  |  |  ------------------
  |  |  |  |  420|     26|			(*ctx) << message;                                                                                         \
  |  |  |  |  421|     26|			logger.emit(std::move(ctx));                                                                               \
  |  |  |  |  422|     26|		}                                                                                                              \
  |  |  |  |  423|     26|	} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (423:11): [Folded, False: 26]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  751|     26|			                                                 << std::to_string(pcapFileHeader.version_minor));
  752|     26|			return false;
  753|     26|		}
  754|       |
  755|    741|		constexpr uint32_t MAX_SNAPLEN = 1024 * 1024;
  756|    741|		if (pcapFileHeader.snaplen == 0 || pcapFileHeader.snaplen > MAX_SNAPLEN)
  ------------------
  |  Branch (756:7): [True: 1, False: 740]
  |  Branch (756:38): [True: 39, False: 701]
  ------------------
  757|     40|		{
  758|     40|			PCPP_LOG_ERROR("Invalid snapshot length: " << std::to_string(pcapFileHeader.snaplen));
  ------------------
  |  |  444|     40|#	define PCPP_LOG_ERROR(message) PCPP_LOG(pcpp::LogLevel::Error, message)
  |  |  ------------------
  |  |  |  |  413|     40|	do                                                                                                                 \
  |  |  |  |  414|     40|	{                                                                                                                  \
  |  |  |  |  415|     40|		auto& logger = pcpp::Logger::getInstance();                                                                    \
  |  |  |  |  416|     40|		if (logger.shouldLog(level, LOG_MODULE))                                                                       \
  |  |  |  |  ------------------
  |  |  |  |  |  |    3|     40|#define LOG_MODULE PcapLogModuleFileDevice
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (416:7): [True: 40, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  417|     40|		{                                                                                                              \
  |  |  |  |  418|     40|			auto ctx =                                                                                                 \
  |  |  |  |  419|     40|			    logger.createLogContext(level, pcpp::LogSource(LOG_MODULE, PCAPPP_FILENAME, __FUNCTION__, __LINE__));  \
  |  |  |  |  ------------------
  |  |  |  |  |  |    3|     40|#define LOG_MODULE PcapLogModuleFileDevice
  |  |  |  |  ------------------
  |  |  |  |               			    logger.createLogContext(level, pcpp::LogSource(LOG_MODULE, PCAPPP_FILENAME, __FUNCTION__, __LINE__));  \
  |  |  |  |  ------------------
  |  |  |  |  |  |   20|       |#	define PCAPPP_FILENAME __FILE_NAME__
  |  |  |  |  ------------------
  |  |  |  |  420|     40|			(*ctx) << message;                                                                                         \
  |  |  |  |  421|     40|			logger.emit(std::move(ctx));                                                                               \
  |  |  |  |  422|     40|		}                                                                                                              \
  |  |  |  |  423|     40|	} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (423:11): [Folded, False: 40]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  759|     40|			return false;
  760|     40|		}
  761|       |
  762|    701|		m_PcapLinkLayerType = toLinkLayerType(pcapFileHeader.linktype);
  763|       |
  764|    701|		m_SnapshotLength = pcapFileHeader.snaplen;
  765|    701|		m_ReadBuffer.resize(m_SnapshotLength);
  766|       |
  767|    701|		m_PcapFile = std::move(pcapFile);
  768|    701|		return true;
  769|    741|	}
_ZN4pcpp20PcapFileReaderDevice13getNextPacketERNS_9RawPacketE:
  772|  5.01k|	{
  773|  5.01k|		timespec packetTimestamp;
  774|  5.01k|		uint32_t capturedLength = 0, frameLength = 0;
  775|       |
  776|  5.01k|		while (readNextPacket(packetTimestamp, m_ReadBuffer.data(), m_SnapshotLength, capturedLength, frameLength))
  ------------------
  |  Branch (776:10): [True: 4.31k, False: 701]
  ------------------
  777|  4.31k|		{
  778|  4.31k|			if (m_BpfWrapper.matches(m_ReadBuffer.data(), capturedLength, packetTimestamp, m_PcapLinkLayerType))
  ------------------
  |  Branch (778:8): [True: 4.31k, False: 0]
  ------------------
  779|  4.31k|			{
  780|       |				// TODO: Fixup tirage hack of adding 20 bytes buffer to pass fuzz.
  781|  4.31k|				auto packetData = std::make_unique<uint8_t[]>(capturedLength /* + 200 */);
  782|  4.31k|				std::copy(m_ReadBuffer.begin(), std::next(m_ReadBuffer.begin(), capturedLength), packetData.get());
  783|       |
  784|  4.31k|				rawPacket.setRawData(capturedLength > 0 ? packetData.release() : nullptr, capturedLength, true,
  ------------------
  |  Branch (784:26): [True: 3.04k, False: 1.27k]
  ------------------
  785|  4.31k|				                     packetTimestamp, m_PcapLinkLayerType, frameLength);
  786|  4.31k|				reportPacketProcessed();
  787|  4.31k|				return true;
  788|  4.31k|			}
  789|      0|			PCPP_LOG_DEBUG("Packet doesn't match filter");
  ------------------
  |  |  426|      0|#	define PCPP_LOG_DEBUG(message) PCPP_LOG(pcpp::LogLevel::Debug, message)
  |  |  ------------------
  |  |  |  |  413|      0|	do                                                                                                                 \
  |  |  |  |  414|      0|	{                                                                                                                  \
  |  |  |  |  415|      0|		auto& logger = pcpp::Logger::getInstance();                                                                    \
  |  |  |  |  416|      0|		if (logger.shouldLog(level, LOG_MODULE))                                                                       \
  |  |  |  |  ------------------
  |  |  |  |  |  |    3|      0|#define LOG_MODULE PcapLogModuleFileDevice
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (416:7): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  417|      0|		{                                                                                                              \
  |  |  |  |  418|      0|			auto ctx =                                                                                                 \
  |  |  |  |  419|      0|			    logger.createLogContext(level, pcpp::LogSource(LOG_MODULE, PCAPPP_FILENAME, __FUNCTION__, __LINE__));  \
  |  |  |  |  ------------------
  |  |  |  |  |  |    3|      0|#define LOG_MODULE PcapLogModuleFileDevice
  |  |  |  |  ------------------
  |  |  |  |               			    logger.createLogContext(level, pcpp::LogSource(LOG_MODULE, PCAPPP_FILENAME, __FUNCTION__, __LINE__));  \
  |  |  |  |  ------------------
  |  |  |  |  |  |   20|       |#	define PCAPPP_FILENAME __FILE_NAME__
  |  |  |  |  ------------------
  |  |  |  |  420|      0|			(*ctx) << message;                                                                                         \
  |  |  |  |  421|      0|			logger.emit(std::move(ctx));                                                                               \
  |  |  |  |  422|      0|		}                                                                                                              \
  |  |  |  |  423|      0|	} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (423:11): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  790|      0|		}
  791|       |
  792|    701|		return false;
  793|  5.01k|	}
_ZN4pcpp20PcapFileReaderDevice14readNextPacketER8timespecPhjRjS4_:
  802|  5.01k|	{
  803|  5.01k|		packet_header packetHeader{};
  804|  5.01k|		m_PcapFile.read(reinterpret_cast<char*>(&packetHeader), sizeof(packetHeader));
  805|       |
  806|  5.01k|		auto bytesRead = m_PcapFile.gcount();
  807|  5.01k|		if (bytesRead == 0)
  ------------------
  |  Branch (807:7): [True: 498, False: 4.51k]
  ------------------
  808|    498|		{
  809|    498|			return false;
  810|    498|		}
  811|       |
  812|  4.51k|		if (static_cast<size_t>(bytesRead) < sizeof(packetHeader))
  ------------------
  |  Branch (812:7): [True: 19, False: 4.50k]
  ------------------
  813|     19|		{
  814|     19|			PCPP_LOG_ERROR("Failed to read packet metadata");
  ------------------
  |  |  444|     19|#	define PCPP_LOG_ERROR(message) PCPP_LOG(pcpp::LogLevel::Error, message)
  |  |  ------------------
  |  |  |  |  413|     19|	do                                                                                                                 \
  |  |  |  |  414|     19|	{                                                                                                                  \
  |  |  |  |  415|     19|		auto& logger = pcpp::Logger::getInstance();                                                                    \
  |  |  |  |  416|     19|		if (logger.shouldLog(level, LOG_MODULE))                                                                       \
  |  |  |  |  ------------------
  |  |  |  |  |  |    3|     19|#define LOG_MODULE PcapLogModuleFileDevice
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (416:7): [True: 19, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  417|     19|		{                                                                                                              \
  |  |  |  |  418|     19|			auto ctx =                                                                                                 \
  |  |  |  |  419|     19|			    logger.createLogContext(level, pcpp::LogSource(LOG_MODULE, PCAPPP_FILENAME, __FUNCTION__, __LINE__));  \
  |  |  |  |  ------------------
  |  |  |  |  |  |    3|     19|#define LOG_MODULE PcapLogModuleFileDevice
  |  |  |  |  ------------------
  |  |  |  |               			    logger.createLogContext(level, pcpp::LogSource(LOG_MODULE, PCAPPP_FILENAME, __FUNCTION__, __LINE__));  \
  |  |  |  |  ------------------
  |  |  |  |  |  |   20|       |#	define PCAPPP_FILENAME __FILE_NAME__
  |  |  |  |  ------------------
  |  |  |  |  420|     19|			(*ctx) << message;                                                                                         \
  |  |  |  |  421|     19|			logger.emit(std::move(ctx));                                                                               \
  |  |  |  |  422|     19|		}                                                                                                              \
  |  |  |  |  423|     19|	} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (423:11): [Folded, False: 19]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  815|     19|			return false;
  816|     19|		}
  817|       |
  818|  4.50k|		if (m_NeedsSwap)
  ------------------
  |  Branch (818:7): [True: 3.84k, False: 660]
  ------------------
  819|  3.84k|		{
  820|  3.84k|			packetHeader.tv_sec = swap32(packetHeader.tv_sec);
  821|  3.84k|			packetHeader.tv_usec = swap32(packetHeader.tv_usec);
  822|  3.84k|			packetHeader.caplen = swap32(packetHeader.caplen);
  823|  3.84k|			packetHeader.len = swap32(packetHeader.len);
  824|  3.84k|		}
  825|       |
  826|  4.50k|		if (packetHeader.caplen > packetHeader.len)
  ------------------
  |  Branch (826:7): [True: 19, False: 4.48k]
  ------------------
  827|     19|		{
  828|     19|			PCPP_LOG_ERROR("Packet captured length " << packetHeader.caplen << " exceeds packet length "
  ------------------
  |  |  444|     19|#	define PCPP_LOG_ERROR(message) PCPP_LOG(pcpp::LogLevel::Error, message)
  |  |  ------------------
  |  |  |  |  413|     19|	do                                                                                                                 \
  |  |  |  |  414|     19|	{                                                                                                                  \
  |  |  |  |  415|     19|		auto& logger = pcpp::Logger::getInstance();                                                                    \
  |  |  |  |  416|     19|		if (logger.shouldLog(level, LOG_MODULE))                                                                       \
  |  |  |  |  ------------------
  |  |  |  |  |  |    3|     19|#define LOG_MODULE PcapLogModuleFileDevice
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (416:7): [True: 19, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  417|     19|		{                                                                                                              \
  |  |  |  |  418|     19|			auto ctx =                                                                                                 \
  |  |  |  |  419|     19|			    logger.createLogContext(level, pcpp::LogSource(LOG_MODULE, PCAPPP_FILENAME, __FUNCTION__, __LINE__));  \
  |  |  |  |  ------------------
  |  |  |  |  |  |    3|     19|#define LOG_MODULE PcapLogModuleFileDevice
  |  |  |  |  ------------------
  |  |  |  |               			    logger.createLogContext(level, pcpp::LogSource(LOG_MODULE, PCAPPP_FILENAME, __FUNCTION__, __LINE__));  \
  |  |  |  |  ------------------
  |  |  |  |  |  |   20|       |#	define PCAPPP_FILENAME __FILE_NAME__
  |  |  |  |  ------------------
  |  |  |  |  420|     19|			(*ctx) << message;                                                                                         \
  |  |  |  |  421|     19|			logger.emit(std::move(ctx));                                                                               \
  |  |  |  |  422|     19|		}                                                                                                              \
  |  |  |  |  423|     19|	} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (423:11): [Folded, False: 19]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  829|     19|			                                         << packetHeader.len);
  830|     19|			return false;
  831|     19|		}
  832|       |
  833|  4.48k|		constexpr uint32_t MAX_PACKET_SIZE = 256 * 1024;
  834|  4.48k|		if (packetHeader.caplen > MAX_PACKET_SIZE)
  ------------------
  |  Branch (834:7): [True: 31, False: 4.45k]
  ------------------
  835|     31|		{
  836|     31|			PCPP_LOG_ERROR("Packet captured length " << packetHeader.caplen << " is suspiciously large");
  ------------------
  |  |  444|     31|#	define PCPP_LOG_ERROR(message) PCPP_LOG(pcpp::LogLevel::Error, message)
  |  |  ------------------
  |  |  |  |  413|     31|	do                                                                                                                 \
  |  |  |  |  414|     31|	{                                                                                                                  \
  |  |  |  |  415|     31|		auto& logger = pcpp::Logger::getInstance();                                                                    \
  |  |  |  |  416|     31|		if (logger.shouldLog(level, LOG_MODULE))                                                                       \
  |  |  |  |  ------------------
  |  |  |  |  |  |    3|     31|#define LOG_MODULE PcapLogModuleFileDevice
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (416:7): [True: 31, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  417|     31|		{                                                                                                              \
  |  |  |  |  418|     31|			auto ctx =                                                                                                 \
  |  |  |  |  419|     31|			    logger.createLogContext(level, pcpp::LogSource(LOG_MODULE, PCAPPP_FILENAME, __FUNCTION__, __LINE__));  \
  |  |  |  |  ------------------
  |  |  |  |  |  |    3|     31|#define LOG_MODULE PcapLogModuleFileDevice
  |  |  |  |  ------------------
  |  |  |  |               			    logger.createLogContext(level, pcpp::LogSource(LOG_MODULE, PCAPPP_FILENAME, __FUNCTION__, __LINE__));  \
  |  |  |  |  ------------------
  |  |  |  |  |  |   20|       |#	define PCAPPP_FILENAME __FILE_NAME__
  |  |  |  |  ------------------
  |  |  |  |  420|     31|			(*ctx) << message;                                                                                         \
  |  |  |  |  421|     31|			logger.emit(std::move(ctx));                                                                               \
  |  |  |  |  422|     31|		}                                                                                                              \
  |  |  |  |  423|     31|	} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (423:11): [Folded, False: 31]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  837|     31|			return false;
  838|     31|		}
  839|       |
  840|  4.45k|		if (m_Precision == FileTimestampPrecision::Nanoseconds)
  ------------------
  |  Branch (840:7): [True: 2.64k, False: 1.80k]
  ------------------
  841|  2.64k|		{
  842|  2.64k|			constexpr uint32_t NANO_PER_SEC = 1'000'000'000;
  843|  2.64k|			if (packetHeader.tv_usec >= NANO_PER_SEC)
  ------------------
  |  Branch (843:8): [True: 21, False: 2.62k]
  ------------------
  844|     21|			{
  845|     21|				PCPP_LOG_ERROR("Invalid nanosecond timestamp: " << std::to_string(packetHeader.tv_usec));
  ------------------
  |  |  444|     21|#	define PCPP_LOG_ERROR(message) PCPP_LOG(pcpp::LogLevel::Error, message)
  |  |  ------------------
  |  |  |  |  413|     21|	do                                                                                                                 \
  |  |  |  |  414|     21|	{                                                                                                                  \
  |  |  |  |  415|     21|		auto& logger = pcpp::Logger::getInstance();                                                                    \
  |  |  |  |  416|     21|		if (logger.shouldLog(level, LOG_MODULE))                                                                       \
  |  |  |  |  ------------------
  |  |  |  |  |  |    3|     21|#define LOG_MODULE PcapLogModuleFileDevice
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (416:7): [True: 21, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  417|     21|		{                                                                                                              \
  |  |  |  |  418|     21|			auto ctx =                                                                                                 \
  |  |  |  |  419|     21|			    logger.createLogContext(level, pcpp::LogSource(LOG_MODULE, PCAPPP_FILENAME, __FUNCTION__, __LINE__));  \
  |  |  |  |  ------------------
  |  |  |  |  |  |    3|     21|#define LOG_MODULE PcapLogModuleFileDevice
  |  |  |  |  ------------------
  |  |  |  |               			    logger.createLogContext(level, pcpp::LogSource(LOG_MODULE, PCAPPP_FILENAME, __FUNCTION__, __LINE__));  \
  |  |  |  |  ------------------
  |  |  |  |  |  |   20|       |#	define PCAPPP_FILENAME __FILE_NAME__
  |  |  |  |  ------------------
  |  |  |  |  420|     21|			(*ctx) << message;                                                                                         \
  |  |  |  |  421|     21|			logger.emit(std::move(ctx));                                                                               \
  |  |  |  |  422|     21|		}                                                                                                              \
  |  |  |  |  423|     21|	} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (423:11): [Folded, False: 21]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  846|     21|				return false;
  847|     21|			}
  848|  2.64k|		}
  849|  1.80k|		else
  850|  1.80k|		{
  851|  1.80k|			constexpr uint32_t MICRO_PER_SEC = 1'000'000;
  852|  1.80k|			if (packetHeader.tv_usec >= MICRO_PER_SEC)
  ------------------
  |  Branch (852:8): [True: 33, False: 1.77k]
  ------------------
  853|     33|			{
  854|     33|				PCPP_LOG_ERROR("Invalid microsecond timestamp: " << std::to_string(packetHeader.tv_usec));
  ------------------
  |  |  444|     33|#	define PCPP_LOG_ERROR(message) PCPP_LOG(pcpp::LogLevel::Error, message)
  |  |  ------------------
  |  |  |  |  413|     33|	do                                                                                                                 \
  |  |  |  |  414|     33|	{                                                                                                                  \
  |  |  |  |  415|     33|		auto& logger = pcpp::Logger::getInstance();                                                                    \
  |  |  |  |  416|     33|		if (logger.shouldLog(level, LOG_MODULE))                                                                       \
  |  |  |  |  ------------------
  |  |  |  |  |  |    3|     33|#define LOG_MODULE PcapLogModuleFileDevice
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (416:7): [True: 33, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  417|     33|		{                                                                                                              \
  |  |  |  |  418|     33|			auto ctx =                                                                                                 \
  |  |  |  |  419|     33|			    logger.createLogContext(level, pcpp::LogSource(LOG_MODULE, PCAPPP_FILENAME, __FUNCTION__, __LINE__));  \
  |  |  |  |  ------------------
  |  |  |  |  |  |    3|     33|#define LOG_MODULE PcapLogModuleFileDevice
  |  |  |  |  ------------------
  |  |  |  |               			    logger.createLogContext(level, pcpp::LogSource(LOG_MODULE, PCAPPP_FILENAME, __FUNCTION__, __LINE__));  \
  |  |  |  |  ------------------
  |  |  |  |  |  |   20|       |#	define PCAPPP_FILENAME __FILE_NAME__
  |  |  |  |  ------------------
  |  |  |  |  420|     33|			(*ctx) << message;                                                                                         \
  |  |  |  |  421|     33|			logger.emit(std::move(ctx));                                                                               \
  |  |  |  |  422|     33|		}                                                                                                              \
  |  |  |  |  423|     33|	} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (423:11): [Folded, False: 33]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  855|     33|				return false;
  856|     33|			}
  857|  1.80k|		}
  858|       |
  859|  4.39k|		uint32_t bytesToDiscard = 0;
  860|  4.39k|		if (packetHeader.caplen > packetDataLen)
  ------------------
  |  Branch (860:7): [True: 890, False: 3.50k]
  ------------------
  861|    890|		{
  862|    890|			PCPP_LOG_WARN("Packet captured length " << packetHeader.caplen << " exceeds file snapshot length "
  ------------------
  |  |  432|    890|#	define PCPP_LOG_WARN(message) PCPP_LOG(pcpp::LogLevel::Warn, message)
  |  |  ------------------
  |  |  |  |  413|    890|	do                                                                                                                 \
  |  |  |  |  414|    890|	{                                                                                                                  \
  |  |  |  |  415|    890|		auto& logger = pcpp::Logger::getInstance();                                                                    \
  |  |  |  |  416|    890|		if (logger.shouldLog(level, LOG_MODULE))                                                                       \
  |  |  |  |  ------------------
  |  |  |  |  |  |    3|    890|#define LOG_MODULE PcapLogModuleFileDevice
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (416:7): [True: 890, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  417|    890|		{                                                                                                              \
  |  |  |  |  418|    890|			auto ctx =                                                                                                 \
  |  |  |  |  419|    890|			    logger.createLogContext(level, pcpp::LogSource(LOG_MODULE, PCAPPP_FILENAME, __FUNCTION__, __LINE__));  \
  |  |  |  |  ------------------
  |  |  |  |  |  |    3|    890|#define LOG_MODULE PcapLogModuleFileDevice
  |  |  |  |  ------------------
  |  |  |  |               			    logger.createLogContext(level, pcpp::LogSource(LOG_MODULE, PCAPPP_FILENAME, __FUNCTION__, __LINE__));  \
  |  |  |  |  ------------------
  |  |  |  |  |  |   20|       |#	define PCAPPP_FILENAME __FILE_NAME__
  |  |  |  |  ------------------
  |  |  |  |  420|    890|			(*ctx) << message;                                                                                         \
  |  |  |  |  421|    890|			logger.emit(std::move(ctx));                                                                               \
  |  |  |  |  422|    890|		}                                                                                                              \
  |  |  |  |  423|    890|	} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (423:11): [Folded, False: 890]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  863|    890|			                                        << packetDataLen);
  864|    890|			bytesToDiscard = packetHeader.caplen - packetDataLen;
  865|    890|			packetHeader.caplen = packetDataLen;
  866|    890|		}
  867|       |
  868|  4.39k|		if (packetHeader.caplen > 0 && !m_PcapFile.read(reinterpret_cast<char*>(packetData), packetHeader.caplen))
  ------------------
  |  Branch (868:7): [True: 3.12k, False: 1.27k]
  |  Branch (868:34): [True: 80, False: 3.04k]
  ------------------
  869|     80|		{
  870|     80|			PCPP_LOG_ERROR("Failed to read packet data");
  ------------------
  |  |  444|     80|#	define PCPP_LOG_ERROR(message) PCPP_LOG(pcpp::LogLevel::Error, message)
  |  |  ------------------
  |  |  |  |  413|     80|	do                                                                                                                 \
  |  |  |  |  414|     80|	{                                                                                                                  \
  |  |  |  |  415|     80|		auto& logger = pcpp::Logger::getInstance();                                                                    \
  |  |  |  |  416|     80|		if (logger.shouldLog(level, LOG_MODULE))                                                                       \
  |  |  |  |  ------------------
  |  |  |  |  |  |    3|     80|#define LOG_MODULE PcapLogModuleFileDevice
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (416:7): [True: 80, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  417|     80|		{                                                                                                              \
  |  |  |  |  418|     80|			auto ctx =                                                                                                 \
  |  |  |  |  419|     80|			    logger.createLogContext(level, pcpp::LogSource(LOG_MODULE, PCAPPP_FILENAME, __FUNCTION__, __LINE__));  \
  |  |  |  |  ------------------
  |  |  |  |  |  |    3|     80|#define LOG_MODULE PcapLogModuleFileDevice
  |  |  |  |  ------------------
  |  |  |  |               			    logger.createLogContext(level, pcpp::LogSource(LOG_MODULE, PCAPPP_FILENAME, __FUNCTION__, __LINE__));  \
  |  |  |  |  ------------------
  |  |  |  |  |  |   20|       |#	define PCAPPP_FILENAME __FILE_NAME__
  |  |  |  |  ------------------
  |  |  |  |  420|     80|			(*ctx) << message;                                                                                         \
  |  |  |  |  421|     80|			logger.emit(std::move(ctx));                                                                               \
  |  |  |  |  422|     80|		}                                                                                                              \
  |  |  |  |  423|     80|	} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (423:11): [Folded, False: 80]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  871|     80|			return false;
  872|     80|		}
  873|       |
  874|  4.31k|		if (bytesToDiscard && !m_PcapFile.ignore(bytesToDiscard))
  ------------------
  |  Branch (874:7): [True: 845, False: 3.47k]
  |  Branch (874:25): [True: 0, False: 845]
  ------------------
  875|      0|		{
  876|      0|			PCPP_LOG_ERROR("Failed to read discarded packet data");
  ------------------
  |  |  444|      0|#	define PCPP_LOG_ERROR(message) PCPP_LOG(pcpp::LogLevel::Error, message)
  |  |  ------------------
  |  |  |  |  413|      0|	do                                                                                                                 \
  |  |  |  |  414|      0|	{                                                                                                                  \
  |  |  |  |  415|      0|		auto& logger = pcpp::Logger::getInstance();                                                                    \
  |  |  |  |  416|      0|		if (logger.shouldLog(level, LOG_MODULE))                                                                       \
  |  |  |  |  ------------------
  |  |  |  |  |  |    3|      0|#define LOG_MODULE PcapLogModuleFileDevice
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (416:7): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  417|      0|		{                                                                                                              \
  |  |  |  |  418|      0|			auto ctx =                                                                                                 \
  |  |  |  |  419|      0|			    logger.createLogContext(level, pcpp::LogSource(LOG_MODULE, PCAPPP_FILENAME, __FUNCTION__, __LINE__));  \
  |  |  |  |  ------------------
  |  |  |  |  |  |    3|      0|#define LOG_MODULE PcapLogModuleFileDevice
  |  |  |  |  ------------------
  |  |  |  |               			    logger.createLogContext(level, pcpp::LogSource(LOG_MODULE, PCAPPP_FILENAME, __FUNCTION__, __LINE__));  \
  |  |  |  |  ------------------
  |  |  |  |  |  |   20|       |#	define PCAPPP_FILENAME __FILE_NAME__
  |  |  |  |  ------------------
  |  |  |  |  420|      0|			(*ctx) << message;                                                                                         \
  |  |  |  |  421|      0|			logger.emit(std::move(ctx));                                                                               \
  |  |  |  |  422|      0|		}                                                                                                              \
  |  |  |  |  423|      0|	} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (423:11): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  877|      0|			return false;
  878|      0|		}
  879|       |
  880|  4.31k|		capturedLength = packetHeader.caplen;
  881|  4.31k|		frameLength = packetHeader.len;
  882|  4.31k|		packetTimestamp = { static_cast<time_t>(packetHeader.tv_sec),
  883|  4.31k|			                static_cast<long>(m_Precision == FileTimestampPrecision::Microseconds
  ------------------
  |  Branch (883:38): [True: 1.75k, False: 2.55k]
  ------------------
  884|  4.31k|			                                      ? packetHeader.tv_usec * 1000
  885|  4.31k|			                                      : packetHeader.tv_usec) };
  886|  4.31k|		return true;
  887|  4.31k|	}
_ZN4pcpp22PcapNgFileWriterDeviceC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEi:
 1327|    701|	    : IFileWriterDevice(fileName)
 1328|    701|	{
 1329|    701|		m_LightPcapNg = nullptr;
 1330|    701|		m_CompressionLevel = compressionLevel;
 1331|    701|	}
_ZN4pcpp22PcapNgFileWriterDevice11writePacketERKNS_9RawPacketERKNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEE:
 1334|  4.31k|	{
 1335|  4.31k|		if (m_LightPcapNg == nullptr)
  ------------------
  |  Branch (1335:7): [True: 0, False: 4.31k]
  ------------------
 1336|      0|		{
 1337|      0|			PCPP_LOG_ERROR("Device not opened");
  ------------------
  |  |  444|      0|#	define PCPP_LOG_ERROR(message) PCPP_LOG(pcpp::LogLevel::Error, message)
  |  |  ------------------
  |  |  |  |  413|      0|	do                                                                                                                 \
  |  |  |  |  414|      0|	{                                                                                                                  \
  |  |  |  |  415|      0|		auto& logger = pcpp::Logger::getInstance();                                                                    \
  |  |  |  |  416|      0|		if (logger.shouldLog(level, LOG_MODULE))                                                                       \
  |  |  |  |  ------------------
  |  |  |  |  |  |    3|      0|#define LOG_MODULE PcapLogModuleFileDevice
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (416:7): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  417|      0|		{                                                                                                              \
  |  |  |  |  418|      0|			auto ctx =                                                                                                 \
  |  |  |  |  419|      0|			    logger.createLogContext(level, pcpp::LogSource(LOG_MODULE, PCAPPP_FILENAME, __FUNCTION__, __LINE__));  \
  |  |  |  |  ------------------
  |  |  |  |  |  |    3|      0|#define LOG_MODULE PcapLogModuleFileDevice
  |  |  |  |  ------------------
  |  |  |  |               			    logger.createLogContext(level, pcpp::LogSource(LOG_MODULE, PCAPPP_FILENAME, __FUNCTION__, __LINE__));  \
  |  |  |  |  ------------------
  |  |  |  |  |  |   20|       |#	define PCAPPP_FILENAME __FILE_NAME__
  |  |  |  |  ------------------
  |  |  |  |  420|      0|			(*ctx) << message;                                                                                         \
  |  |  |  |  421|      0|			logger.emit(std::move(ctx));                                                                               \
  |  |  |  |  422|      0|		}                                                                                                              \
  |  |  |  |  423|      0|	} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (423:11): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1338|      0|			reportPacketDropped();
 1339|      0|			return false;
 1340|      0|		}
 1341|       |
 1342|  4.31k|		if (!m_BpfWrapper.matches(packet))
  ------------------
  |  Branch (1342:7): [True: 0, False: 4.31k]
  ------------------
 1343|      0|		{
 1344|      0|			return false;
 1345|      0|		}
 1346|       |
 1347|  4.31k|		light_packet_header pktHeader;
 1348|  4.31k|		pktHeader.captured_length = packet.getRawDataLen();
 1349|  4.31k|		pktHeader.original_length = packet.getFrameLength();
 1350|  4.31k|		pktHeader.timestamp = packet.getPacketTimeStamp();
 1351|  4.31k|		pktHeader.data_link = static_cast<uint16_t>(packet.getLinkLayerType());
 1352|  4.31k|		pktHeader.interface_id = 0;
 1353|  4.31k|		if (!comment.empty())
  ------------------
  |  Branch (1353:7): [True: 0, False: 4.31k]
  ------------------
 1354|      0|		{
 1355|      0|			pktHeader.comment = const_cast<char*>(comment.c_str());
 1356|      0|			pktHeader.comment_length = static_cast<uint16_t>(comment.size());
 1357|      0|		}
 1358|  4.31k|		else
 1359|  4.31k|		{
 1360|  4.31k|			pktHeader.comment = nullptr;
 1361|  4.31k|			pktHeader.comment_length = 0;
 1362|  4.31k|		}
 1363|       |
 1364|  4.31k|		const uint8_t* pktData = packet.getRawData();
 1365|       |
 1366|  4.31k|		light_write_packet(toLightPcapNgT(m_LightPcapNg), &pktHeader, pktData);
 1367|  4.31k|		reportPacketProcessed();
 1368|  4.31k|		return true;
 1369|  4.31k|	}
_ZN4pcpp22PcapNgFileWriterDevice11writePacketERKNS_9RawPacketE:
 1372|  4.31k|	{
 1373|  4.31k|		return writePacket(packet, std::string());
 1374|  4.31k|	}
_ZN4pcpp22PcapNgFileWriterDevice4openEb:
 1393|    701|	{
 1394|    701|		return appendMode ? openAppend() : openWrite();
  ------------------
  |  Branch (1394:10): [True: 630, False: 71]
  ------------------
 1395|    701|	}
_ZN4pcpp22PcapNgFileWriterDevice9openWriteEPKNS0_14PcapNgMetadataE:
 1409|     71|	{
 1410|       |		// TODO: Ambiguity in the API
 1411|       |		//   If the user calls open() and then open(true) - should we close the first one or report failure?
 1412|       |		//   Currently the method reports a success, but the opened device would not match the appendMode.
 1413|     71|		if (m_LightPcapNg != nullptr)
  ------------------
  |  Branch (1413:7): [True: 0, False: 71]
  ------------------
 1414|      0|		{
 1415|      0|			PCPP_LOG_DEBUG("Pcap-ng descriptor already opened. Nothing to do");
  ------------------
  |  |  426|      0|#	define PCPP_LOG_DEBUG(message) PCPP_LOG(pcpp::LogLevel::Debug, message)
  |  |  ------------------
  |  |  |  |  413|      0|	do                                                                                                                 \
  |  |  |  |  414|      0|	{                                                                                                                  \
  |  |  |  |  415|      0|		auto& logger = pcpp::Logger::getInstance();                                                                    \
  |  |  |  |  416|      0|		if (logger.shouldLog(level, LOG_MODULE))                                                                       \
  |  |  |  |  ------------------
  |  |  |  |  |  |    3|      0|#define LOG_MODULE PcapLogModuleFileDevice
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (416:7): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  417|      0|		{                                                                                                              \
  |  |  |  |  418|      0|			auto ctx =                                                                                                 \
  |  |  |  |  419|      0|			    logger.createLogContext(level, pcpp::LogSource(LOG_MODULE, PCAPPP_FILENAME, __FUNCTION__, __LINE__));  \
  |  |  |  |  ------------------
  |  |  |  |  |  |    3|      0|#define LOG_MODULE PcapLogModuleFileDevice
  |  |  |  |  ------------------
  |  |  |  |               			    logger.createLogContext(level, pcpp::LogSource(LOG_MODULE, PCAPPP_FILENAME, __FUNCTION__, __LINE__));  \
  |  |  |  |  ------------------
  |  |  |  |  |  |   20|       |#	define PCAPPP_FILENAME __FILE_NAME__
  |  |  |  |  ------------------
  |  |  |  |  420|      0|			(*ctx) << message;                                                                                         \
  |  |  |  |  421|      0|			logger.emit(std::move(ctx));                                                                               \
  |  |  |  |  422|      0|		}                                                                                                              \
  |  |  |  |  423|      0|	} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (423:11): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1416|      0|			return true;
 1417|      0|		}
 1418|       |
 1419|     71|		resetStatisticCounters();
 1420|       |
 1421|     71|		light_pcapng_file_info* info;
 1422|     71|		if (metadata == nullptr)
  ------------------
  |  Branch (1422:7): [True: 71, False: 0]
  ------------------
 1423|     71|		{
 1424|     71|			info = light_create_default_file_info();
 1425|     71|		}
 1426|      0|		else
 1427|      0|		{
 1428|      0|			info = light_create_file_info(metadata->os.c_str(), metadata->hardware.c_str(),
 1429|      0|			                              metadata->captureApplication.c_str(), metadata->comment.c_str());
 1430|      0|		}
 1431|       |
 1432|     71|		m_LightPcapNg = toLightPcapNgHandle(light_pcapng_open_write(m_FileName.c_str(), info, m_CompressionLevel));
 1433|     71|		if (m_LightPcapNg == nullptr)
  ------------------
  |  Branch (1433:7): [True: 0, False: 71]
  ------------------
 1434|      0|		{
 1435|      0|			PCPP_LOG_ERROR("Error opening file writer device for file '"
  ------------------
  |  |  444|      0|#	define PCPP_LOG_ERROR(message) PCPP_LOG(pcpp::LogLevel::Error, message)
  |  |  ------------------
  |  |  |  |  413|      0|	do                                                                                                                 \
  |  |  |  |  414|      0|	{                                                                                                                  \
  |  |  |  |  415|      0|		auto& logger = pcpp::Logger::getInstance();                                                                    \
  |  |  |  |  416|      0|		if (logger.shouldLog(level, LOG_MODULE))                                                                       \
  |  |  |  |  ------------------
  |  |  |  |  |  |    3|      0|#define LOG_MODULE PcapLogModuleFileDevice
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (416:7): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  417|      0|		{                                                                                                              \
  |  |  |  |  418|      0|			auto ctx =                                                                                                 \
  |  |  |  |  419|      0|			    logger.createLogContext(level, pcpp::LogSource(LOG_MODULE, PCAPPP_FILENAME, __FUNCTION__, __LINE__));  \
  |  |  |  |  ------------------
  |  |  |  |  |  |    3|      0|#define LOG_MODULE PcapLogModuleFileDevice
  |  |  |  |  ------------------
  |  |  |  |               			    logger.createLogContext(level, pcpp::LogSource(LOG_MODULE, PCAPPP_FILENAME, __FUNCTION__, __LINE__));  \
  |  |  |  |  ------------------
  |  |  |  |  |  |   20|       |#	define PCAPPP_FILENAME __FILE_NAME__
  |  |  |  |  ------------------
  |  |  |  |  420|      0|			(*ctx) << message;                                                                                         \
  |  |  |  |  421|      0|			logger.emit(std::move(ctx));                                                                               \
  |  |  |  |  422|      0|		}                                                                                                              \
  |  |  |  |  423|      0|	} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (423:11): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1436|      0|			               << m_FileName << "': light_pcapng_open_write returned nullptr");
 1437|       |
 1438|      0|			light_free_file_info(info);
 1439|       |
 1440|      0|			return false;
 1441|      0|		}
 1442|       |
 1443|     71|		PCPP_LOG_DEBUG("pcap-ng writer device for file '" << m_FileName << "' opened successfully");
  ------------------
  |  |  426|     71|#	define PCPP_LOG_DEBUG(message) PCPP_LOG(pcpp::LogLevel::Debug, message)
  |  |  ------------------
  |  |  |  |  413|     71|	do                                                                                                                 \
  |  |  |  |  414|     71|	{                                                                                                                  \
  |  |  |  |  415|     71|		auto& logger = pcpp::Logger::getInstance();                                                                    \
  |  |  |  |  416|     71|		if (logger.shouldLog(level, LOG_MODULE))                                                                       \
  |  |  |  |  ------------------
  |  |  |  |  |  |    3|     71|#define LOG_MODULE PcapLogModuleFileDevice
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (416:7): [True: 0, False: 71]
  |  |  |  |  ------------------
  |  |  |  |  417|     71|		{                                                                                                              \
  |  |  |  |  418|      0|			auto ctx =                                                                                                 \
  |  |  |  |  419|      0|			    logger.createLogContext(level, pcpp::LogSource(LOG_MODULE, PCAPPP_FILENAME, __FUNCTION__, __LINE__));  \
  |  |  |  |  ------------------
  |  |  |  |  |  |    3|      0|#define LOG_MODULE PcapLogModuleFileDevice
  |  |  |  |  ------------------
  |  |  |  |               			    logger.createLogContext(level, pcpp::LogSource(LOG_MODULE, PCAPPP_FILENAME, __FUNCTION__, __LINE__));  \
  |  |  |  |  ------------------
  |  |  |  |  |  |   20|       |#	define PCAPPP_FILENAME __FILE_NAME__
  |  |  |  |  ------------------
  |  |  |  |  420|      0|			(*ctx) << message;                                                                                         \
  |  |  |  |  421|      0|			logger.emit(std::move(ctx));                                                                               \
  |  |  |  |  422|      0|		}                                                                                                              \
  |  |  |  |  423|     71|	} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (423:11): [Folded, False: 71]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1444|     71|		return true;
 1445|     71|	}
_ZN4pcpp22PcapNgFileWriterDevice10openAppendEv:
 1448|    630|	{
 1449|       |		// TODO: Ambiguity in the API
 1450|       |		//   If the user calls open() and then open(true) - should we close the first one or report failure?
 1451|       |		//   Currently the method reports a success, but the opened device would not match the appendMode.
 1452|    630|		if (m_LightPcapNg != nullptr)
  ------------------
  |  Branch (1452:7): [True: 0, False: 630]
  ------------------
 1453|      0|		{
 1454|      0|			PCPP_LOG_DEBUG("Pcap-ng descriptor already opened. Nothing to do");
  ------------------
  |  |  426|      0|#	define PCPP_LOG_DEBUG(message) PCPP_LOG(pcpp::LogLevel::Debug, message)
  |  |  ------------------
  |  |  |  |  413|      0|	do                                                                                                                 \
  |  |  |  |  414|      0|	{                                                                                                                  \
  |  |  |  |  415|      0|		auto& logger = pcpp::Logger::getInstance();                                                                    \
  |  |  |  |  416|      0|		if (logger.shouldLog(level, LOG_MODULE))                                                                       \
  |  |  |  |  ------------------
  |  |  |  |  |  |    3|      0|#define LOG_MODULE PcapLogModuleFileDevice
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (416:7): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  417|      0|		{                                                                                                              \
  |  |  |  |  418|      0|			auto ctx =                                                                                                 \
  |  |  |  |  419|      0|			    logger.createLogContext(level, pcpp::LogSource(LOG_MODULE, PCAPPP_FILENAME, __FUNCTION__, __LINE__));  \
  |  |  |  |  ------------------
  |  |  |  |  |  |    3|      0|#define LOG_MODULE PcapLogModuleFileDevice
  |  |  |  |  ------------------
  |  |  |  |               			    logger.createLogContext(level, pcpp::LogSource(LOG_MODULE, PCAPPP_FILENAME, __FUNCTION__, __LINE__));  \
  |  |  |  |  ------------------
  |  |  |  |  |  |   20|       |#	define PCAPPP_FILENAME __FILE_NAME__
  |  |  |  |  ------------------
  |  |  |  |  420|      0|			(*ctx) << message;                                                                                         \
  |  |  |  |  421|      0|			logger.emit(std::move(ctx));                                                                               \
  |  |  |  |  422|      0|		}                                                                                                              \
  |  |  |  |  423|      0|	} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (423:11): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1455|      0|			return true;
 1456|      0|		}
 1457|       |
 1458|    630|		resetStatisticCounters();
 1459|       |
 1460|    630|		m_LightPcapNg = toLightPcapNgHandle(light_pcapng_open_append(m_FileName.c_str()));
 1461|    630|		if (m_LightPcapNg == nullptr)
  ------------------
  |  Branch (1461:7): [True: 0, False: 630]
  ------------------
 1462|      0|		{
 1463|      0|			PCPP_LOG_ERROR("Error opening file writer device in append mode for file '"
  ------------------
  |  |  444|      0|#	define PCPP_LOG_ERROR(message) PCPP_LOG(pcpp::LogLevel::Error, message)
  |  |  ------------------
  |  |  |  |  413|      0|	do                                                                                                                 \
  |  |  |  |  414|      0|	{                                                                                                                  \
  |  |  |  |  415|      0|		auto& logger = pcpp::Logger::getInstance();                                                                    \
  |  |  |  |  416|      0|		if (logger.shouldLog(level, LOG_MODULE))                                                                       \
  |  |  |  |  ------------------
  |  |  |  |  |  |    3|      0|#define LOG_MODULE PcapLogModuleFileDevice
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (416:7): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  417|      0|		{                                                                                                              \
  |  |  |  |  418|      0|			auto ctx =                                                                                                 \
  |  |  |  |  419|      0|			    logger.createLogContext(level, pcpp::LogSource(LOG_MODULE, PCAPPP_FILENAME, __FUNCTION__, __LINE__));  \
  |  |  |  |  ------------------
  |  |  |  |  |  |    3|      0|#define LOG_MODULE PcapLogModuleFileDevice
  |  |  |  |  ------------------
  |  |  |  |               			    logger.createLogContext(level, pcpp::LogSource(LOG_MODULE, PCAPPP_FILENAME, __FUNCTION__, __LINE__));  \
  |  |  |  |  ------------------
  |  |  |  |  |  |   20|       |#	define PCAPPP_FILENAME __FILE_NAME__
  |  |  |  |  ------------------
  |  |  |  |  420|      0|			(*ctx) << message;                                                                                         \
  |  |  |  |  421|      0|			logger.emit(std::move(ctx));                                                                               \
  |  |  |  |  422|      0|		}                                                                                                              \
  |  |  |  |  423|      0|	} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (423:11): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1464|      0|			               << m_FileName << "': light_pcapng_open_append returned nullptr");
 1465|      0|			return false;
 1466|      0|		}
 1467|       |
 1468|    630|		PCPP_LOG_DEBUG("pcap-ng writer device for file '" << m_FileName << "' opened successfully");
  ------------------
  |  |  426|    630|#	define PCPP_LOG_DEBUG(message) PCPP_LOG(pcpp::LogLevel::Debug, message)
  |  |  ------------------
  |  |  |  |  413|    630|	do                                                                                                                 \
  |  |  |  |  414|    630|	{                                                                                                                  \
  |  |  |  |  415|    630|		auto& logger = pcpp::Logger::getInstance();                                                                    \
  |  |  |  |  416|    630|		if (logger.shouldLog(level, LOG_MODULE))                                                                       \
  |  |  |  |  ------------------
  |  |  |  |  |  |    3|    630|#define LOG_MODULE PcapLogModuleFileDevice
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (416:7): [True: 0, False: 630]
  |  |  |  |  ------------------
  |  |  |  |  417|    630|		{                                                                                                              \
  |  |  |  |  418|      0|			auto ctx =                                                                                                 \
  |  |  |  |  419|      0|			    logger.createLogContext(level, pcpp::LogSource(LOG_MODULE, PCAPPP_FILENAME, __FUNCTION__, __LINE__));  \
  |  |  |  |  ------------------
  |  |  |  |  |  |    3|      0|#define LOG_MODULE PcapLogModuleFileDevice
  |  |  |  |  ------------------
  |  |  |  |               			    logger.createLogContext(level, pcpp::LogSource(LOG_MODULE, PCAPPP_FILENAME, __FUNCTION__, __LINE__));  \
  |  |  |  |  ------------------
  |  |  |  |  |  |   20|       |#	define PCAPPP_FILENAME __FILE_NAME__
  |  |  |  |  ------------------
  |  |  |  |  420|      0|			(*ctx) << message;                                                                                         \
  |  |  |  |  421|      0|			logger.emit(std::move(ctx));                                                                               \
  |  |  |  |  422|      0|		}                                                                                                              \
  |  |  |  |  423|    630|	} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (423:11): [Folded, False: 630]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1469|    630|		return true;
 1470|    630|	}
_ZN4pcpp22PcapNgFileWriterDevice5closeEv:
 1482|  1.05k|	{
 1483|  1.05k|		if (m_LightPcapNg == nullptr)
  ------------------
  |  Branch (1483:7): [True: 355, False: 701]
  ------------------
 1484|    355|			return;
 1485|       |
 1486|    701|		light_pcapng_close(toLightPcapNgT(m_LightPcapNg));
 1487|    701|		m_LightPcapNg = nullptr;
 1488|       |
 1489|    701|		PCPP_LOG_DEBUG("File writer closed for file '" << m_FileName << "'");
  ------------------
  |  |  426|    701|#	define PCPP_LOG_DEBUG(message) PCPP_LOG(pcpp::LogLevel::Debug, message)
  |  |  ------------------
  |  |  |  |  413|    701|	do                                                                                                                 \
  |  |  |  |  414|    701|	{                                                                                                                  \
  |  |  |  |  415|    701|		auto& logger = pcpp::Logger::getInstance();                                                                    \
  |  |  |  |  416|    701|		if (logger.shouldLog(level, LOG_MODULE))                                                                       \
  |  |  |  |  ------------------
  |  |  |  |  |  |    3|    701|#define LOG_MODULE PcapLogModuleFileDevice
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (416:7): [True: 0, False: 701]
  |  |  |  |  ------------------
  |  |  |  |  417|    701|		{                                                                                                              \
  |  |  |  |  418|      0|			auto ctx =                                                                                                 \
  |  |  |  |  419|      0|			    logger.createLogContext(level, pcpp::LogSource(LOG_MODULE, PCAPPP_FILENAME, __FUNCTION__, __LINE__));  \
  |  |  |  |  ------------------
  |  |  |  |  |  |    3|      0|#define LOG_MODULE PcapLogModuleFileDevice
  |  |  |  |  ------------------
  |  |  |  |               			    logger.createLogContext(level, pcpp::LogSource(LOG_MODULE, PCAPPP_FILENAME, __FUNCTION__, __LINE__));  \
  |  |  |  |  ------------------
  |  |  |  |  |  |   20|       |#	define PCAPPP_FILENAME __FILE_NAME__
  |  |  |  |  ------------------
  |  |  |  |  420|      0|			(*ctx) << message;                                                                                         \
  |  |  |  |  421|      0|			logger.emit(std::move(ctx));                                                                               \
  |  |  |  |  422|      0|		}                                                                                                              \
  |  |  |  |  423|    701|	} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (423:11): [Folded, False: 701]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1490|    701|	}
PcapFileDevice.cpp:_ZN4pcpp12_GLOBAL__N_115detectPcapMagicEjPNS0_13FileByteOrderE:
  286|    771|		{
  287|       |			// Pcap magic numbers are taken from: https://github.com/the-tcpdump-group/libpcap/blob/master/sf-pcap.c
  288|       |			// There are some other reserved magic numbers but they are not supported by libpcap so we ignore them.
  289|       |			// The order of the magic numbers in the array is important for format detection. See switch statement
  290|       |			// below.
  291|    771|			constexpr std::array<uint32_t, 6> pcapMagicNumbers = {
  292|    771|				TCPDUMP_MAGIC,          // 0xa1'b2'c3'd4 - regular pcap, microsecond-precision
  293|    771|				TCPDUMP_MAGIC_SWAPPED,  // 0xd4'c3'b2'a1 - regular pcap, microsecond-precision (byte-swapped)
  294|       |				// Libpcap 0.9.1 and later support reading a modified pcap format that contains an extended header.
  295|       |				// Format reference: https://wiki.wireshark.org/Development/LibpcapFileFormat#modified-pcap
  296|    771|				KUZNETZOV_TCPDUMP_MAGIC,          // Alexey Kuznetzov's modified libpcap format
  297|    771|				KUZNETZOV_TCPDUMP_MAGIC_SWAPPED,  // Alexey Kuznetzov's modified libpcap format (byte-swapped)
  298|       |				// Libpcap 1.5.0 and later support reading nanosecond-precision pcap files.
  299|    771|				NSEC_TCPDUMP_MAGIC,          // 0xa1'b2'3c'4d - regular pcap, nanosecond-precision
  300|    771|				NSEC_TCPDUMP_MAGIC_SWAPPED,  // 0x4d'3c'b2'a1 - regular pcap, nanosecond-precision (byte-swapped)
  301|    771|			};
  302|       |
  303|    771|			auto it = std::find(pcapMagicNumbers.begin(), pcapMagicNumbers.end(), magic);
  304|    771|			if (it == pcapMagicNumbers.end())
  ------------------
  |  Branch (304:8): [True: 4, False: 767]
  ------------------
  305|      4|			{
  306|      4|				return FileFormat::Unknown;
  307|      4|			}
  308|       |
  309|       |			// Indices 0-1 are regular microsecond-precision pcap files.
  310|       |			// Indices 2-3 are "modified" pcap files
  311|       |			// Indices 4-5 are nanosecond-precision pcap files.
  312|    767|			auto const selectedIdx = std::distance(pcapMagicNumbers.begin(), it);
  313|       |
  314|    767|			if (byteOrder != nullptr)
  ------------------
  |  Branch (314:8): [True: 767, False: 0]
  ------------------
  315|    767|			{
  316|    767|				*byteOrder = (selectedIdx % 2 == 0) ? FileByteOrder::Native : FileByteOrder::Swapped;
  ------------------
  |  Branch (316:18): [True: 180, False: 587]
  ------------------
  317|    767|			}
  318|       |
  319|    767|			if (selectedIdx < 2)
  ------------------
  |  Branch (319:8): [True: 312, False: 455]
  ------------------
  320|    312|			{
  321|    312|				return FileFormat::Pcap;
  322|    312|			}
  323|    455|			if (selectedIdx < 4)
  ------------------
  |  Branch (323:8): [True: 5, False: 450]
  ------------------
  324|      5|			{
  325|      5|				return FileFormat::PcapMod;
  326|      5|			}
  327|       |
  328|    450|			return FileFormat::PcapNano;
  329|    455|		}
PcapFileDevice.cpp:_ZN4pcpp12_GLOBAL__N_114readPcapHeaderERNSt3__113basic_istreamIcNS1_11char_traitsIcEEEERNS0_16pcap_file_headerERNS_22FileTimestampPrecisionERb:
  670|    781|		{
  671|    781|			inStream.read(reinterpret_cast<char*>(&header), sizeof(header));
  672|       |
  673|    781|			auto readBytes = inStream.gcount();
  674|    781|			if (readBytes == 0)
  ------------------
  |  Branch (674:8): [True: 0, False: 781]
  ------------------
  675|      0|			{
  676|      0|				return PcapReadHeaderStatus::NoData;
  677|      0|			}
  678|    781|			if (readBytes < static_cast<std::streamsize>(sizeof(header)))
  ------------------
  |  Branch (678:8): [True: 10, False: 771]
  ------------------
  679|     10|			{
  680|     10|				return PcapReadHeaderStatus::MalformedData;
  681|     10|			}
  682|       |
  683|    771|			FileByteOrder byteOrder;
  684|    771|			FileFormat pcapFormat = detectPcapMagic(header.magic, &byteOrder);
  685|    771|			if (pcapFormat == FileFormat::Unknown)
  ------------------
  |  Branch (685:8): [True: 4, False: 767]
  ------------------
  686|      4|			{
  687|      4|				return PcapReadHeaderStatus::UnsupportedFormat;
  688|      4|			}
  689|       |
  690|    767|			precision = getPcapPrecision(pcapFormat);
  691|    767|			needsSwap = byteOrder == FileByteOrder::Swapped;
  692|       |
  693|    767|			if (needsSwap)
  ------------------
  |  Branch (693:8): [True: 587, False: 180]
  ------------------
  694|    587|			{
  695|    587|				header.magic = swap32(header.magic);
  696|    587|				header.version_major = swap16(header.version_major);
  697|    587|				header.version_minor = swap16(header.version_minor);
  698|    587|				header.thiszone = swap32(header.thiszone);
  699|    587|				header.sigfigs = swap32(header.sigfigs);
  700|    587|				header.snaplen = swap32(header.snaplen);
  701|    587|				header.linktype = swap32(header.linktype);
  702|    587|			}
  703|       |
  704|    767|			return PcapReadHeaderStatus::Ok;
  705|    771|		}
PcapFileDevice.cpp:_ZN4pcpp12_GLOBAL__N_116getPcapPrecisionENS0_10FileFormatE:
  462|    767|		{
  463|    767|			switch (format)
  464|    767|			{
  465|    312|			case FileFormat::Pcap:
  ------------------
  |  Branch (465:4): [True: 312, False: 455]
  ------------------
  466|    317|			case FileFormat::PcapMod:
  ------------------
  |  Branch (466:4): [True: 5, False: 762]
  ------------------
  467|    317|				return FileTimestampPrecision::Microseconds;
  468|    450|			case FileFormat::PcapNano:
  ------------------
  |  Branch (468:4): [True: 450, False: 317]
  ------------------
  469|    450|				return FileTimestampPrecision::Nanoseconds;
  470|      0|			default:
  ------------------
  |  Branch (470:4): [True: 0, False: 767]
  ------------------
  471|      0|				return FileTimestampPrecision::Unknown;
  472|    767|			}
  473|    767|		}
PcapFileDevice.cpp:_ZN4pcpp12_GLOBAL__N_16swap16Et:
  641|  1.17k|		{
  642|  1.17k|			return static_cast<uint16_t>((value >> 8) | (value << 8));
  643|  1.17k|		}
PcapFileDevice.cpp:_ZN4pcpp12_GLOBAL__N_115toLinkLayerTypeEj:
   91|    701|		{
   92|    701|			switch (value)
   93|    701|			{
   94|     47|			case LINKTYPE_NULL:
  ------------------
  |  Branch (94:4): [True: 47, False: 654]
  ------------------
   95|     59|			case LINKTYPE_ETHERNET:
  ------------------
  |  Branch (95:4): [True: 12, False: 689]
  ------------------
   96|     66|			case LINKTYPE_AX25:
  ------------------
  |  Branch (96:4): [True: 7, False: 694]
  ------------------
   97|     76|			case LINKTYPE_IEEE802_5:
  ------------------
  |  Branch (97:4): [True: 10, False: 691]
  ------------------
   98|     77|			case LINKTYPE_ARCNET_BSD:
  ------------------
  |  Branch (98:4): [True: 1, False: 700]
  ------------------
   99|     80|			case LINKTYPE_SLIP:
  ------------------
  |  Branch (99:4): [True: 3, False: 698]
  ------------------
  100|     95|			case LINKTYPE_PPP:
  ------------------
  |  Branch (100:4): [True: 15, False: 686]
  ------------------
  101|     96|			case LINKTYPE_FDDI:
  ------------------
  |  Branch (101:4): [True: 1, False: 700]
  ------------------
  102|     97|			case LINKTYPE_DLT_RAW1:
  ------------------
  |  Branch (102:4): [True: 1, False: 700]
  ------------------
  103|     98|			case LINKTYPE_DLT_RAW2:
  ------------------
  |  Branch (103:4): [True: 1, False: 700]
  ------------------
  104|    102|			case LINKTYPE_PPP_HDLC:
  ------------------
  |  Branch (104:4): [True: 4, False: 697]
  ------------------
  105|    103|			case LINKTYPE_PPP_ETHER:
  ------------------
  |  Branch (105:4): [True: 1, False: 700]
  ------------------
  106|    104|			case LINKTYPE_ATM_RFC1483:
  ------------------
  |  Branch (106:4): [True: 1, False: 700]
  ------------------
  107|    108|			case LINKTYPE_RAW:
  ------------------
  |  Branch (107:4): [True: 4, False: 697]
  ------------------
  108|    109|			case LINKTYPE_C_HDLC:
  ------------------
  |  Branch (108:4): [True: 1, False: 700]
  ------------------
  109|    110|			case LINKTYPE_IEEE802_11:
  ------------------
  |  Branch (109:4): [True: 1, False: 700]
  ------------------
  110|    111|			case LINKTYPE_FRELAY:
  ------------------
  |  Branch (110:4): [True: 1, False: 700]
  ------------------
  111|    114|			case LINKTYPE_LOOP:
  ------------------
  |  Branch (111:4): [True: 3, False: 698]
  ------------------
  112|    117|			case LINKTYPE_LINUX_SLL:
  ------------------
  |  Branch (112:4): [True: 3, False: 698]
  ------------------
  113|    118|			case LINKTYPE_LTALK:
  ------------------
  |  Branch (113:4): [True: 1, False: 700]
  ------------------
  114|    119|			case LINKTYPE_PFLOG:
  ------------------
  |  Branch (114:4): [True: 1, False: 700]
  ------------------
  115|    121|			case LINKTYPE_IEEE802_11_PRISM:
  ------------------
  |  Branch (115:4): [True: 2, False: 699]
  ------------------
  116|    123|			case LINKTYPE_IP_OVER_FC:
  ------------------
  |  Branch (116:4): [True: 2, False: 699]
  ------------------
  117|    124|			case LINKTYPE_SUNATM:
  ------------------
  |  Branch (117:4): [True: 1, False: 700]
  ------------------
  118|    125|			case LINKTYPE_IEEE802_11_RADIOTAP:
  ------------------
  |  Branch (118:4): [True: 1, False: 700]
  ------------------
  119|    126|			case LINKTYPE_ARCNET_LINUX:
  ------------------
  |  Branch (119:4): [True: 1, False: 700]
  ------------------
  120|    127|			case LINKTYPE_APPLE_IP_OVER_IEEE1394:
  ------------------
  |  Branch (120:4): [True: 1, False: 700]
  ------------------
  121|    128|			case LINKTYPE_MTP2_WITH_PHDR:
  ------------------
  |  Branch (121:4): [True: 1, False: 700]
  ------------------
  122|    133|			case LINKTYPE_MTP2:
  ------------------
  |  Branch (122:4): [True: 5, False: 696]
  ------------------
  123|    134|			case LINKTYPE_MTP3:
  ------------------
  |  Branch (123:4): [True: 1, False: 700]
  ------------------
  124|    135|			case LINKTYPE_SCCP:
  ------------------
  |  Branch (124:4): [True: 1, False: 700]
  ------------------
  125|    136|			case LINKTYPE_DOCSIS:
  ------------------
  |  Branch (125:4): [True: 1, False: 700]
  ------------------
  126|    138|			case LINKTYPE_LINUX_IRDA:
  ------------------
  |  Branch (126:4): [True: 2, False: 699]
  ------------------
  127|    139|			case LINKTYPE_USER0:
  ------------------
  |  Branch (127:4): [True: 1, False: 700]
  ------------------
  128|    140|			case LINKTYPE_USER1:
  ------------------
  |  Branch (128:4): [True: 1, False: 700]
  ------------------
  129|    144|			case LINKTYPE_USER2:
  ------------------
  |  Branch (129:4): [True: 4, False: 697]
  ------------------
  130|    145|			case LINKTYPE_USER3:
  ------------------
  |  Branch (130:4): [True: 1, False: 700]
  ------------------
  131|    146|			case LINKTYPE_USER4:
  ------------------
  |  Branch (131:4): [True: 1, False: 700]
  ------------------
  132|    148|			case LINKTYPE_USER5:
  ------------------
  |  Branch (132:4): [True: 2, False: 699]
  ------------------
  133|    149|			case LINKTYPE_USER6:
  ------------------
  |  Branch (133:4): [True: 1, False: 700]
  ------------------
  134|    151|			case LINKTYPE_USER7:
  ------------------
  |  Branch (134:4): [True: 2, False: 699]
  ------------------
  135|    152|			case LINKTYPE_USER8:
  ------------------
  |  Branch (135:4): [True: 1, False: 700]
  ------------------
  136|    153|			case LINKTYPE_USER9:
  ------------------
  |  Branch (136:4): [True: 1, False: 700]
  ------------------
  137|    154|			case LINKTYPE_USER10:
  ------------------
  |  Branch (137:4): [True: 1, False: 700]
  ------------------
  138|    155|			case LINKTYPE_USER11:
  ------------------
  |  Branch (138:4): [True: 1, False: 700]
  ------------------
  139|    168|			case LINKTYPE_USER12:
  ------------------
  |  Branch (139:4): [True: 13, False: 688]
  ------------------
  140|    169|			case LINKTYPE_USER13:
  ------------------
  |  Branch (140:4): [True: 1, False: 700]
  ------------------
  141|    170|			case LINKTYPE_USER14:
  ------------------
  |  Branch (141:4): [True: 1, False: 700]
  ------------------
  142|    171|			case LINKTYPE_USER15:
  ------------------
  |  Branch (142:4): [True: 1, False: 700]
  ------------------
  143|    173|			case LINKTYPE_IEEE802_11_AVS:
  ------------------
  |  Branch (143:4): [True: 2, False: 699]
  ------------------
  144|    174|			case LINKTYPE_BACNET_MS_TP:
  ------------------
  |  Branch (144:4): [True: 1, False: 700]
  ------------------
  145|    176|			case LINKTYPE_PPP_PPPD:
  ------------------
  |  Branch (145:4): [True: 2, False: 699]
  ------------------
  146|    177|			case LINKTYPE_GPRS_LLC:
  ------------------
  |  Branch (146:4): [True: 1, False: 700]
  ------------------
  147|    178|			case LINKTYPE_GPF_T:
  ------------------
  |  Branch (147:4): [True: 1, False: 700]
  ------------------
  148|    180|			case LINKTYPE_GPF_F:
  ------------------
  |  Branch (148:4): [True: 2, False: 699]
  ------------------
  149|    181|			case LINKTYPE_LINUX_LAPD:
  ------------------
  |  Branch (149:4): [True: 1, False: 700]
  ------------------
  150|    182|			case LINKTYPE_BLUETOOTH_HCI_H4:
  ------------------
  |  Branch (150:4): [True: 1, False: 700]
  ------------------
  151|    184|			case LINKTYPE_USB_LINUX:
  ------------------
  |  Branch (151:4): [True: 2, False: 699]
  ------------------
  152|    192|			case LINKTYPE_PPI:
  ------------------
  |  Branch (152:4): [True: 8, False: 693]
  ------------------
  153|    196|			case LINKTYPE_IEEE802_15_4:
  ------------------
  |  Branch (153:4): [True: 4, False: 697]
  ------------------
  154|    197|			case LINKTYPE_SITA:
  ------------------
  |  Branch (154:4): [True: 1, False: 700]
  ------------------
  155|    199|			case LINKTYPE_ERF:
  ------------------
  |  Branch (155:4): [True: 2, False: 699]
  ------------------
  156|    200|			case LINKTYPE_BLUETOOTH_HCI_H4_WITH_PHDR:
  ------------------
  |  Branch (156:4): [True: 1, False: 700]
  ------------------
  157|    201|			case LINKTYPE_AX25_KISS:
  ------------------
  |  Branch (157:4): [True: 1, False: 700]
  ------------------
  158|    210|			case LINKTYPE_LAPD:
  ------------------
  |  Branch (158:4): [True: 9, False: 692]
  ------------------
  159|    211|			case LINKTYPE_PPP_WITH_DIR:
  ------------------
  |  Branch (159:4): [True: 1, False: 700]
  ------------------
  160|    212|			case LINKTYPE_C_HDLC_WITH_DIR:
  ------------------
  |  Branch (160:4): [True: 1, False: 700]
  ------------------
  161|    213|			case LINKTYPE_FRELAY_WITH_DIR:
  ------------------
  |  Branch (161:4): [True: 1, False: 700]
  ------------------
  162|    215|			case LINKTYPE_IPMB_LINUX:
  ------------------
  |  Branch (162:4): [True: 2, False: 699]
  ------------------
  163|    216|			case LINKTYPE_IEEE802_15_4_NONASK_PHY:
  ------------------
  |  Branch (163:4): [True: 1, False: 700]
  ------------------
  164|    220|			case LINKTYPE_USB_LINUX_MMAPPED:
  ------------------
  |  Branch (164:4): [True: 4, False: 697]
  ------------------
  165|    222|			case LINKTYPE_FC_2:
  ------------------
  |  Branch (165:4): [True: 2, False: 699]
  ------------------
  166|    223|			case LINKTYPE_FC_2_WITH_FRAME_DELIMS:
  ------------------
  |  Branch (166:4): [True: 1, False: 700]
  ------------------
  167|    225|			case LINKTYPE_IPNET:
  ------------------
  |  Branch (167:4): [True: 2, False: 699]
  ------------------
  168|    226|			case LINKTYPE_CAN_SOCKETCAN:
  ------------------
  |  Branch (168:4): [True: 1, False: 700]
  ------------------
  169|    231|			case LINKTYPE_IPV4:
  ------------------
  |  Branch (169:4): [True: 5, False: 696]
  ------------------
  170|    233|			case LINKTYPE_IPV6:
  ------------------
  |  Branch (170:4): [True: 2, False: 699]
  ------------------
  171|    240|			case LINKTYPE_IEEE802_15_4_NOFCS:
  ------------------
  |  Branch (171:4): [True: 7, False: 694]
  ------------------
  172|    242|			case LINKTYPE_DBUS:
  ------------------
  |  Branch (172:4): [True: 2, False: 699]
  ------------------
  173|    243|			case LINKTYPE_DVB_CI:
  ------------------
  |  Branch (173:4): [True: 1, False: 700]
  ------------------
  174|    246|			case LINKTYPE_MUX27010:
  ------------------
  |  Branch (174:4): [True: 3, False: 698]
  ------------------
  175|    247|			case LINKTYPE_STANAG_5066_D_PDU:
  ------------------
  |  Branch (175:4): [True: 1, False: 700]
  ------------------
  176|    249|			case LINKTYPE_NFLOG:
  ------------------
  |  Branch (176:4): [True: 2, False: 699]
  ------------------
  177|    250|			case LINKTYPE_NETANALYZER:
  ------------------
  |  Branch (177:4): [True: 1, False: 700]
  ------------------
  178|    251|			case LINKTYPE_NETANALYZER_TRANSPARENT:
  ------------------
  |  Branch (178:4): [True: 1, False: 700]
  ------------------
  179|    252|			case LINKTYPE_IPOIB:
  ------------------
  |  Branch (179:4): [True: 1, False: 700]
  ------------------
  180|    253|			case LINKTYPE_MPEG_2_TS:
  ------------------
  |  Branch (180:4): [True: 1, False: 700]
  ------------------
  181|    254|			case LINKTYPE_NG40:
  ------------------
  |  Branch (181:4): [True: 1, False: 700]
  ------------------
  182|    270|			case LINKTYPE_NFC_LLCP:
  ------------------
  |  Branch (182:4): [True: 16, False: 685]
  ------------------
  183|    272|			case LINKTYPE_INFINIBAND:
  ------------------
  |  Branch (183:4): [True: 2, False: 699]
  ------------------
  184|    273|			case LINKTYPE_SCTP:
  ------------------
  |  Branch (184:4): [True: 1, False: 700]
  ------------------
  185|    275|			case LINKTYPE_USBPCAP:
  ------------------
  |  Branch (185:4): [True: 2, False: 699]
  ------------------
  186|    276|			case LINKTYPE_RTAC_SERIAL:
  ------------------
  |  Branch (186:4): [True: 1, False: 700]
  ------------------
  187|    278|			case LINKTYPE_BLUETOOTH_LE_LL:
  ------------------
  |  Branch (187:4): [True: 2, False: 699]
  ------------------
  188|    279|			case LINKTYPE_NETLINK:
  ------------------
  |  Branch (188:4): [True: 1, False: 700]
  ------------------
  189|    280|			case LINKTYPE_BLUETOOTH_LINUX_MONITOR:
  ------------------
  |  Branch (189:4): [True: 1, False: 700]
  ------------------
  190|    291|			case LINKTYPE_BLUETOOTH_BREDR_BB:
  ------------------
  |  Branch (190:4): [True: 11, False: 690]
  ------------------
  191|    297|			case LINKTYPE_BLUETOOTH_LE_LL_WITH_PHDR:
  ------------------
  |  Branch (191:4): [True: 6, False: 695]
  ------------------
  192|    302|			case LINKTYPE_PROFIBUS_DL:
  ------------------
  |  Branch (192:4): [True: 5, False: 696]
  ------------------
  193|    305|			case LINKTYPE_PKTAP:
  ------------------
  |  Branch (193:4): [True: 3, False: 698]
  ------------------
  194|    306|			case LINKTYPE_EPON:
  ------------------
  |  Branch (194:4): [True: 1, False: 700]
  ------------------
  195|    307|			case LINKTYPE_IPMI_HPM_2:
  ------------------
  |  Branch (195:4): [True: 1, False: 700]
  ------------------
  196|    308|			case LINKTYPE_ZWAVE_R1_R2:
  ------------------
  |  Branch (196:4): [True: 1, False: 700]
  ------------------
  197|    309|			case LINKTYPE_ZWAVE_R3:
  ------------------
  |  Branch (197:4): [True: 1, False: 700]
  ------------------
  198|    310|			case LINKTYPE_WATTSTOPPER_DLM:
  ------------------
  |  Branch (198:4): [True: 1, False: 700]
  ------------------
  199|    312|			case LINKTYPE_ISO_14443:
  ------------------
  |  Branch (199:4): [True: 2, False: 699]
  ------------------
  200|    318|			case LINKTYPE_LINUX_SLL2:
  ------------------
  |  Branch (200:4): [True: 6, False: 695]
  ------------------
  201|    318|			{
  202|    318|				return static_cast<LinkLayerType>(value);
  203|    312|			}
  204|       |
  205|    383|			default:
  ------------------
  |  Branch (205:4): [True: 383, False: 318]
  ------------------
  206|    383|			{
  207|    383|				return LINKTYPE_INVALID;
  208|    312|			}
  209|    701|			}
  210|    701|		}
PcapFileDevice.cpp:_ZN4pcpp12_GLOBAL__N_16swap32Ej:
  646|  18.2k|		{
  647|  18.2k|			return (value >> 24) | ((value >> 8) & 0x0000FF00) | ((value << 8) & 0x00FF0000) | (value << 24);
  648|  18.2k|		}
PcapFileDevice.cpp:_ZN4pcpp12_GLOBAL__N_119toLightPcapNgHandleEP15_light_pcapng_t:
   35|    701|		{
   36|    701|			return reinterpret_cast<internal::LightPcapNgHandle*>(pcapngHandle);
   37|    701|		}
PcapFileDevice.cpp:_ZN4pcpp12_GLOBAL__N_114toLightPcapNgTEPNS_8internal17LightPcapNgHandleE:
   43|  5.01k|		{
   44|  5.01k|			return reinterpret_cast<light_pcapng_t*>(pcapngHandle);
   45|  5.01k|		}

_ZNK4pcpp16BpfFilterWrapper7matchesERKNS_9RawPacketE:
   96|  4.31k|	{
   97|  4.31k|		return matches(rawPacket.getRawData(), rawPacket.getRawDataLen(), rawPacket.getPacketTimeStamp(),
   98|  4.31k|		               rawPacket.getLinkLayerType());
   99|  4.31k|	}
_ZNK4pcpp16BpfFilterWrapper7matchesEPKhj8timespect:
  103|  8.63k|	{
  104|  8.63k|		if (m_FilterStr.empty())
  ------------------
  |  Branch (104:7): [True: 8.63k, False: 0]
  ------------------
  105|  8.63k|			return true;
  106|       |
  107|      0|#ifdef USE_PCAP
  108|       |		// Handle uncompiled program or link type mismatch
  109|      0|		if (m_CachedProgram == nullptr || linkType != static_cast<uint16_t>(m_CachedProgramLinkType))
  ------------------
  |  Branch (109:7): [True: 0, False: 0]
  |  Branch (109:37): [True: 0, False: 0]
  ------------------
  110|      0|		{
  111|      0|			auto newProgram = compileFilter(m_FilterStr, static_cast<LinkLayerType>(linkType));
  112|      0|			if (newProgram == nullptr)
  ------------------
  |  Branch (112:8): [True: 0, False: 0]
  ------------------
  113|      0|			{
  114|      0|				PCPP_LOG_ERROR("Couldn't compile BPF filter: '" << m_FilterStr << "' for link type: " << linkType);
  ------------------
  |  |  444|      0|#	define PCPP_LOG_ERROR(message) PCPP_LOG(pcpp::LogLevel::Error, message)
  |  |  ------------------
  |  |  |  |  413|      0|	do                                                                                                                 \
  |  |  |  |  414|      0|	{                                                                                                                  \
  |  |  |  |  415|      0|		auto& logger = pcpp::Logger::getInstance();                                                                    \
  |  |  |  |  416|      0|		if (logger.shouldLog(level, LOG_MODULE))                                                                       \
  |  |  |  |  ------------------
  |  |  |  |  |  |    1|      0|#define LOG_MODULE PcapLogModuleLiveDevice
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (416:7): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  417|      0|		{                                                                                                              \
  |  |  |  |  418|      0|			auto ctx =                                                                                                 \
  |  |  |  |  419|      0|			    logger.createLogContext(level, pcpp::LogSource(LOG_MODULE, PCAPPP_FILENAME, __FUNCTION__, __LINE__));  \
  |  |  |  |  ------------------
  |  |  |  |  |  |    1|      0|#define LOG_MODULE PcapLogModuleLiveDevice
  |  |  |  |  ------------------
  |  |  |  |               			    logger.createLogContext(level, pcpp::LogSource(LOG_MODULE, PCAPPP_FILENAME, __FUNCTION__, __LINE__));  \
  |  |  |  |  ------------------
  |  |  |  |  |  |   20|       |#	define PCAPPP_FILENAME __FILE_NAME__
  |  |  |  |  ------------------
  |  |  |  |  420|      0|			(*ctx) << message;                                                                                         \
  |  |  |  |  421|      0|			logger.emit(std::move(ctx));                                                                               \
  |  |  |  |  422|      0|		}                                                                                                              \
  |  |  |  |  423|      0|	} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (423:11): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  115|      0|				return false;
  116|      0|			}
  117|      0|			m_CachedProgram = std::move(newProgram);
  118|      0|			m_CachedProgramLinkType = static_cast<LinkLayerType>(linkType);
  119|      0|		}
  120|       |
  121|       |		// Test the packet against the filter
  122|      0|		pcap_pkthdr pktHdr;
  123|      0|		pktHdr.caplen = packetDataLength;
  124|      0|		pktHdr.len = packetDataLength;
  125|      0|		pktHdr.ts = internal::toTimeval(timestamp);
  126|      0|		return (pcap_offline_filter(m_CachedProgram.get(), &pktHdr, packetData) != 0);
  127|       |#else
  128|       |		PCPP_LOG_ERROR("pcap is not available");
  129|       |		return false;
  130|       |#endif
  131|      0|	}

FuzzWriter.cpp:_ZL18dumpDataToPcapFilePKhmPKc:
    8|    781|{
    9|    781|	FILE* fd;
   10|    781|	int written = 0;
   11|       |
   12|    781|	fd = fopen(path, "wb");
   13|    781|	if (fd == nullptr)
  ------------------
  |  Branch (13:6): [True: 0, False: 781]
  ------------------
   14|      0|	{
   15|      0|		std::cerr << "Error opening pcap file for writing\n";
   16|      0|		return -1;
   17|      0|	}
   18|       |
   19|    781|	written = fwrite(data, 1, size, fd);
   20|    781|	if (static_cast<size_t>(written) != size)
  ------------------
  |  Branch (20:6): [True: 0, False: 781]
  ------------------
   21|      0|	{
   22|      0|		std::cerr << "Error writing pcap file\n";
   23|      0|		fclose(fd);
   24|      0|		return -1;
   25|      0|	}
   26|       |
   27|    781|	fclose(fd);
   28|    781|	return 0;
   29|    781|}

LLVMFuzzerTestOneInput:
   14|    781|{
   15|    781|	if (tmpName.empty())
  ------------------
  |  Branch (15:6): [True: 1, False: 780]
  ------------------
   16|      1|		tmpName = tmpnam(nullptr);
   17|       |
   18|    781|	if (tmpFile.empty())
  ------------------
  |  Branch (18:6): [True: 1, False: 780]
  ------------------
   19|      1|		tmpFile = tmpName + FILE_EXT;
   20|       |
   21|    781|	if (dumpDataToPcapFile(data, size, tmpFile.c_str()) != 0)
  ------------------
  |  Branch (21:6): [True: 0, False: 781]
  ------------------
   22|      0|	{
   23|      0|		std::cerr << "Can't Dump buffer to the '" << tmpFile << "' file!!!!\n";
   24|      0|		return -1;
   25|      0|	}
   26|       |
   27|    781|	pcpp::Logger::getInstance().suppressLogs();
   28|       |
   29|    781|	std::unique_ptr<pcpp::IFileReaderDevice> reader(pcpp::IFileReaderDevice::getReader(tmpFile));
   30|    781|	if (!reader->open())
  ------------------
  |  Branch (30:6): [True: 80, False: 701]
  ------------------
   31|     80|	{
   32|     80|		std::cerr << "Error opening the '" << tmpFile << "' file\n";
   33|     80|		return -1;
   34|     80|	}
   35|       |
   36|    701|	if (outPcapFile.empty())
  ------------------
  |  Branch (36:6): [True: 1, False: 700]
  ------------------
   37|      1|#ifdef NG_WRITER
   38|      1|		outPcapFile = tmpName + ".pcapng";
   39|       |#else
   40|       |		outPcapFile = tmpName + ".pcap";
   41|       |#endif
   42|       |
   43|    701|#ifdef NG_WRITER
   44|    701|	pcpp::PcapNgFileWriterDevice pcapWriter(outPcapFile);
   45|       |#else
   46|       |	pcpp::PcapFileWriterDevice pcapWriter(outPcapFile, pcpp::LINKTYPE_ETHERNET);
   47|       |#endif
   48|    701|	if (writes++ == 10)
  ------------------
  |  Branch (48:6): [True: 70, False: 631]
  ------------------
   49|     70|	{
   50|     70|		writes = 1;
   51|     70|		remove(outPcapFile.c_str());
   52|     70|	}
   53|    701|	if (!pcapWriter.open(writes != 1))
  ------------------
  |  Branch (53:6): [True: 0, False: 701]
  ------------------
   54|      0|	{
   55|      0|		std::cerr << "Cannot open '" << outPcapFile << "' for writing" << std::endl;
   56|      0|		return -1;
   57|      0|	}
   58|       |
   59|    701|	pcpp::RawPacketVector packets;
   60|    701|	if (reader->getNextPackets(packets, 1) != 1)
  ------------------
  |  Branch (60:6): [True: 346, False: 355]
  ------------------
   61|    346|	{
   62|    346|		std::cerr << "Couldn't read the first packet in the file\n";
   63|    346|		return 0;
   64|    346|	}
   65|       |
   66|    355|	pcpp::RawPacket& rawPacket = *packets.front();
   67|    355|	do
   68|  4.31k|	{
   69|  4.31k|		pcapWriter.writePacket(rawPacket);
   70|  4.31k|	} while (reader->getNextPacket(rawPacket));
  ------------------
  |  Branch (70:11): [True: 3.96k, False: 355]
  ------------------
   71|       |
   72|    355|	pcpp::PcapStats stats;
   73|    355|	pcapWriter.getStatistics(stats);
   74|    355|	std::cout << "Written " << stats.packetsRecv << " packets successfully to pcap writer and " << stats.packetsDrop
   75|    355|	          << " packets could not be written" << std::endl;
   76|       |
   77|    355|	pcapWriter.close();
   78|    355|	return 0;
   79|    701|}