_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|  12.1k|		{
  369|  12.1k|			static Logger instance;
  370|  12.1k|			return instance;
  371|  12.1k|		}
_ZN4pcpp6Logger12suppressLogsEv:
  320|  1.12k|		{
  321|  1.12k|			m_LogsEnabled = false;
  322|  1.12k|		}
_ZN4pcpp9LogSourceC2ENS_9LogModuleEPKcS3_i:
  138|  6.29k|		    : file(file), function(function), line(line), logModule(logModule)
  139|  6.29k|		{}
_ZN4pcpp8internal10LogContext4initENS_8LogLevelERKNS_9LogSourceE:
  188|  6.29k|			{
  189|  6.29k|				m_Source = source;
  190|  6.29k|				m_Level = level;
  191|  6.29k|				m_Stream.clear();
  192|  6.29k|				m_Stream.str({});
  193|  6.29k|			}
_ZNK4pcpp6Logger9shouldLogENS_8LogLevelENS_9LogModuleE:
  288|  11.0k|		{
  289|  11.0k|			return level != LogLevel::Off && m_LogModulesArray[module] >= level;
  ------------------
  |  Branch (289:11): [True: 11.0k, False: 0]
  |  Branch (289:37): [True: 6.29k, False: 4.75k]
  ------------------
  290|  11.0k|		}
_ZN4pcpp8internal10LogContextlsIA49_cEERS1_RKT_:
  199|  4.82k|			{
  200|  4.82k|				m_Stream << value;
  201|  4.82k|				return *this;
  202|  4.82k|			}
_ZN4pcpp8internal10LogContextlsIA54_cEERS1_RKT_:
  199|  1.46k|			{
  200|  1.46k|				m_Stream << value;
  201|  1.46k|				return *this;
  202|  1.46k|			}
_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|  6.29k|			{
   69|  6.29k|				return std::unique_ptr<T>(acquireObjectRaw());
   70|  6.29k|			}
_ZN4pcpp8internal17DynamicObjectPoolINS0_10LogContextELb1EE16acquireObjectRawEv:
   79|  6.29k|			{
   80|  6.29k|				std::unique_lock<std::mutex> lock(m_Mutex);
   81|       |
   82|  6.29k|				if (m_Pool.empty())
  ------------------
  |  Branch (82:9): [True: 0, False: 6.29k]
  ------------------
   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|  6.29k|				T* obj = m_Pool.top();
   90|  6.29k|				m_Pool.pop();
   91|  6.29k|				return obj;
   92|  6.29k|			}
_ZN4pcpp8internal17DynamicObjectPoolINS0_10LogContextELb1EE13releaseObjectENSt3__110unique_ptrIS2_NS4_14default_deleteIS2_EEEE:
  101|  6.29k|			{
  102|  6.29k|				releaseObjectRaw(obj.release());
  103|  6.29k|			}
_ZN4pcpp8internal17DynamicObjectPoolINS0_10LogContextELb1EE16releaseObjectRawEPS2_:
  112|  6.29k|			{
  113|  6.29k|				std::unique_lock<std::mutex> lock(m_Mutex);
  114|       |
  115|  6.29k|				if (m_MaxPoolSize == INFINITE_POOL_SIZE || m_Pool.size() < m_MaxPoolSize)
  ------------------
  |  Branch (115:9): [True: 0, False: 6.29k]
  |  Branch (115:48): [True: 6.29k, False: 0]
  ------------------
  116|  6.29k|				{
  117|  6.29k|					m_Pool.push(obj);
  118|  6.29k|				}
  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|  6.29k|			}

_ZN4pcpp13PointerVectorINS_9RawPacketENSt3__114default_deleteIS1_EEEC2Ev:
   59|  1.12k|		PointerVector() = default;
_ZN4pcpp13PointerVectorINS_9RawPacketENSt3__114default_deleteIS1_EEED2Ev:
   78|  1.12k|		{
   79|  1.12k|			freeVectorUnsafe(m_Vector);
   80|  1.12k|		}
_ZN4pcpp13PointerVectorINS_9RawPacketENSt3__114default_deleteIS1_EEE16freeVectorUnsafeERKNS2_6vectorIPS1_NS2_9allocatorIS7_EEEE:
  362|  1.12k|		{
  363|  1.12k|			for (auto& obj : origin)
  ------------------
  |  Branch (363:19): [True: 371, False: 1.12k]
  ------------------
  364|    371|			{
  365|    371|				Deleter{}(obj);
  366|    371|			}
  367|  1.12k|		}
_ZNK4pcpp13PointerVectorINS_9RawPacketENSt3__114default_deleteIS1_EEE5frontEv:
  238|    371|		{
  239|    371|			return m_Vector.front();
  240|    371|		}
_ZN4pcpp13PointerVectorINS_9RawPacketENSt3__114default_deleteIS1_EEE8pushBackEPS1_b:
  147|    371|		{
  148|    371|			if (element == nullptr)
  ------------------
  |  Branch (148:8): [True: 0, False: 371]
  ------------------
  149|      0|			{
  150|      0|				throw std::invalid_argument("Element is nullptr");
  151|      0|			}
  152|       |
  153|    371|			try
  154|    371|			{
  155|    371|				m_Vector.push_back(element);
  156|    371|			}
  157|    371|			catch (const std::exception&)
  158|    371|			{
  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|    371|		}

_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|  6.29k|	{
   90|  6.29k|		if (m_UseContextPooling)
  ------------------
  |  Branch (90:7): [True: 6.29k, False: 0]
  ------------------
   91|  6.29k|		{
   92|  6.29k|			auto ctx = m_LogContextPool.acquireObject();
   93|  6.29k|			ctx->init(level, source);
   94|  6.29k|			return ctx;
   95|  6.29k|		}
   96|      0|		return std::make_unique<internal::LogContext>(level, source);
   97|  6.29k|	}
_ZN4pcpp6Logger4emitENSt3__110unique_ptrINS_8internal10LogContextENS1_14default_deleteIS4_EEEE:
  100|  6.29k|	{
  101|  6.29k|		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|  6.29k|		if (m_UseContextPooling)
  ------------------
  |  Branch (103:7): [True: 6.29k, False: 0]
  ------------------
  104|  6.29k|		{
  105|  6.29k|			m_LogContextPool.releaseObject(std::move(message));
  106|  6.29k|		}
  107|  6.29k|	}
_ZN4pcpp6Logger4emitERKNS_9LogSourceENS_8LogLevelERKNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEE:
  110|  6.29k|	{
  111|       |		// If the log level is an error, save the error to the last error message variable.
  112|  6.29k|		if (logLevel == LogLevel::Error)
  ------------------
  |  Branch (112:7): [True: 6.29k, False: 0]
  ------------------
  113|  6.29k|		{
  114|  6.29k|			static_assert(m_LastError.size() >= 1,
  115|  6.29k|			              "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|  6.29k|			auto const copied = message.copy(m_LastError.data(), m_LastError.size() - 1);
  119|  6.29k|			m_LastError[copied] = '\0';
  120|  6.29k|		}
  121|  6.29k|		if (m_LogsEnabled)
  ------------------
  |  Branch (121:7): [True: 0, False: 6.29k]
  ------------------
  122|      0|		{
  123|      0|			m_LogPrinter(logLevel, message, source.file, source.function, source.line);
  124|      0|		}
  125|  6.29k|	}

_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|  7.40k|		{
  695|  7.40k|			return m_RawData;
  696|  7.40k|		}
_ZNK4pcpp9RawPacket16getLinkLayerTypeEv:
  701|  12.2k|		{
  702|  12.2k|			return m_LinkLayerType;
  703|  12.2k|		}
_ZNK4pcpp9RawPacket13getRawDataLenEv:
  713|  11.1k|		{
  714|  11.1k|			return m_RawDataLen;
  715|  11.1k|		}
_ZNK4pcpp9RawPacket14getFrameLengthEv:
  720|  3.70k|		{
  721|  3.70k|			return m_FrameLength;
  722|  3.70k|		}
_ZNK4pcpp9RawPacket18getPacketTimeStampEv:
  726|  7.40k|		{
  727|  7.40k|			return m_TimeStamp;
  728|  7.40k|		}
_ZN4pcpp9RawPacketC2Ev:
  544|  1.12k|		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|  1.12k|	{
   23|  1.12k|		RawPacket::clear();
   24|  1.12k|	}
_ZN4pcpp9RawPacket10setRawDataEPKhib8timespecNS_13LinkLayerTypeEi:
   97|  8.52k|	{
   98|  8.52k|		return doSetRawData(pRawData, rawDataLen, takeOwnership, timestamp, layerType, frameLength);
   99|  8.52k|	}
_ZN4pcpp9RawPacket12doSetRawDataEPKhib8timespecNS_13LinkLayerTypeEi:
  103|  8.52k|	{
  104|  8.52k|		clear();
  105|       |
  106|  8.52k|		m_OwnsRawData = takeOwnership;
  107|  8.52k|		m_FrameLength = (frameLength == -1) ? rawDataLen : frameLength;
  ------------------
  |  Branch (107:19): [True: 419, False: 8.10k]
  ------------------
  108|  8.52k|		m_RawData = (uint8_t*)pRawData;
  109|  8.52k|		m_RawDataLen = rawDataLen;
  110|  8.52k|		m_TimeStamp = timestamp;
  111|  8.52k|		m_RawPacketSet = true;
  112|  8.52k|		m_LinkLayerType = layerType;
  113|  8.52k|		return true;
  114|  8.52k|	}
_ZN4pcpp9RawPacket5clearEv:
  123|  9.64k|	{
  124|  9.64k|		if (m_RawData != nullptr && m_OwnsRawData)
  ------------------
  |  Branch (124:7): [True: 8.52k, False: 1.12k]
  |  Branch (124:31): [True: 8.52k, False: 0]
  ------------------
  125|  8.52k|			delete[] m_RawData;
  126|       |
  127|  9.64k|		m_RawData = nullptr;
  128|  9.64k|		m_RawDataLen = 0;
  129|  9.64k|		m_FrameLength = 0;
  130|  9.64k|		m_RawPacketSet = false;
  131|  9.64k|	}

_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|  2.24k|		virtual ~IDevice() = default;
_ZN4pcpp17IFilterableDeviceC2Ev:
   47|  2.24k|		IFilterableDevice() = default;
_ZN4pcpp7IDeviceC2Ev:
   23|  2.24k|		IDevice() = default;

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

_ZN4pcpp11IFileDevice21reportPacketProcessedEm:
   66|  12.2k|		{
   67|  12.2k|			m_NumOfPacketsProcessed += numPackets;
   68|  12.2k|		}
_ZN4pcpp11IFileDevice19reportPacketDroppedEm:
   73|  4.82k|		{
   74|  4.82k|			m_NumOfPacketsDropped += numPackets;
   75|  4.82k|		}
_ZN4pcpp22PcapNgFileReaderDeviceD2Ev:
  363|  1.12k|		{
  364|  1.12k|			PcapNgFileReaderDevice::close();
  365|  1.12k|		}

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

_ZN4pcpp11IFileDeviceC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  494|  2.24k|	{
  495|  2.24k|		m_FileName = fileName;
  496|  2.24k|	}
_ZNK4pcpp11IFileDevice13getStatisticsERNS_9PcapStatsE:
  504|    371|	{
  505|    371|		PCPP_LOG_DEBUG("Statistics requested for file device for filename '" << m_FileName << "'");
  ------------------
  |  |  426|    371|#	define PCPP_LOG_DEBUG(message) PCPP_LOG(pcpp::LogLevel::Debug, message)
  |  |  ------------------
  |  |  |  |  413|    371|	do                                                                                                                 \
  |  |  |  |  414|    371|	{                                                                                                                  \
  |  |  |  |  415|    371|		auto& logger = pcpp::Logger::getInstance();                                                                    \
  |  |  |  |  416|    371|		if (logger.shouldLog(level, LOG_MODULE))                                                                       \
  |  |  |  |  ------------------
  |  |  |  |  |  |    3|    371|#define LOG_MODULE PcapLogModuleFileDevice
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (416:7): [True: 0, False: 371]
  |  |  |  |  ------------------
  |  |  |  |  417|    371|		{                                                                                                              \
  |  |  |  |  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|    371|	} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (423:11): [Folded, False: 371]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  506|    371|		stats.packetsRecv = m_NumOfPacketsProcessed;
  507|    371|		stats.packetsDrop = m_NumOfPacketsDropped;
  508|    371|		stats.packetsDropByInterface = 0;
  509|    371|	}
_ZN4pcpp11IFileDevice22resetStatisticCountersEv:
  512|  1.12k|	{
  513|  1.12k|		m_NumOfPacketsProcessed = 0;
  514|  1.12k|		m_NumOfPacketsDropped = 0;
  515|  1.12k|	}
_ZN4pcpp17IFileReaderDeviceC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  531|  1.12k|	IFileReaderDevice::IFileReaderDevice(const std::string& fileName) : IFileDevice(fileName)
  532|  1.12k|	{}
_ZN4pcpp17IFileReaderDevice9getReaderERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  535|  1.12k|	{
  536|  1.12k|		const auto extensionPos = fileName.find_last_of('.');
  537|  1.12k|		const auto fileExtension = extensionPos != std::string::npos ? fileName.substr(extensionPos) : "";
  ------------------
  |  Branch (537:30): [True: 1.12k, False: 0]
  ------------------
  538|       |
  539|  1.12k|		if (fileExtension == ".pcapng" || fileExtension == ".zstd" || fileExtension == ".zst")
  ------------------
  |  Branch (539:7): [True: 1.12k, False: 0]
  |  Branch (539:37): [True: 0, False: 0]
  |  Branch (539:65): [True: 0, False: 0]
  ------------------
  540|  1.12k|			return new PcapNgFileReaderDevice(fileName);
  541|      0|		else if (fileExtension == ".snoop")
  ------------------
  |  Branch (541:12): [True: 0, False: 0]
  ------------------
  542|      0|			return new SnoopFileReaderDevice(fileName);
  543|       |
  544|      0|		return new PcapFileReaderDevice(fileName);
  545|  1.12k|	}
_ZN4pcpp17IFileReaderDevice14getNextPacketsERNS_13PointerVectorINS_9RawPacketENSt3__114default_deleteIS2_EEEEi:
  606|  1.12k|	{
  607|  1.12k|		int numOfPacketsRead = 0;
  608|       |
  609|  1.49k|		for (; numOfPacketsToRead < 0 || numOfPacketsRead < numOfPacketsToRead; numOfPacketsRead++)
  ------------------
  |  Branch (609:10): [True: 0, False: 1.49k]
  |  Branch (609:36): [True: 1.12k, False: 371]
  ------------------
  610|  1.12k|		{
  611|  1.12k|			RawPacket* newPacket = new RawPacket();
  612|  1.12k|			bool packetRead = getNextPacket(*newPacket);
  613|  1.12k|			if (packetRead)
  ------------------
  |  Branch (613:8): [True: 371, False: 752]
  ------------------
  614|    371|			{
  615|    371|				packetVec.pushBack(newPacket);
  616|    371|			}
  617|    752|			else
  618|    752|			{
  619|    752|				delete newPacket;
  620|    752|				break;
  621|    752|			}
  622|  1.12k|		}
  623|       |
  624|  1.12k|		return numOfPacketsRead;
  625|  1.12k|	}
_ZN4pcpp17IFileWriterDeviceC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  631|  1.12k|	IFileWriterDevice::IFileWriterDevice(const std::string& fileName) : IFileDevice(fileName)
  632|  1.12k|	{}
_ZN4pcpp20PcapFileWriterDeviceC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_13LinkLayerTypeEb:
  895|  1.12k|	    : IFileWriterDevice(fileName),
  896|  1.12k|	      m_Precision(nanosecondsPrecision ? FileTimestampPrecision::Nanoseconds : FileTimestampPrecision::Microseconds)
  ------------------
  |  Branch (896:20): [True: 0, False: 1.12k]
  ------------------
  897|  1.12k|	{
  898|  1.12k|		if (linkLayerType == LINKTYPE_DLT_RAW1 || linkLayerType == LINKTYPE_DLT_RAW2)
  ------------------
  |  Branch (898:7): [True: 0, False: 1.12k]
  |  Branch (898:45): [True: 0, False: 1.12k]
  ------------------
  899|      0|		{
  900|      0|			m_PcapLinkLayerType = LINKTYPE_RAW;
  901|      0|		}
  902|  1.12k|		else
  903|  1.12k|		{
  904|  1.12k|			m_PcapLinkLayerType = linkLayerType;
  905|  1.12k|		}
  906|  1.12k|	}
_ZN4pcpp20PcapFileWriterDevice4openEb:
  914|  1.12k|	{
  915|  1.12k|		if (m_PcapFile.is_open())
  ------------------
  |  Branch (915:7): [True: 0, False: 1.12k]
  ------------------
  916|      0|		{
  917|      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]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  918|      0|			return false;
  919|      0|		}
  920|       |
  921|  1.12k|		auto flags = std::ios::binary | std::ios::out;
  922|  1.12k|		if (appendMode)
  ------------------
  |  Branch (922:7): [True: 1.01k, False: 113]
  ------------------
  923|  1.01k|		{
  924|  1.01k|			flags |= std::ios::in | std::ios::app;
  925|  1.01k|		}
  926|       |
  927|  1.12k|		std::fstream pcapFile;
  928|  1.12k|		pcapFile.open(m_FileName, flags);
  929|       |
  930|  1.12k|		if (!pcapFile.is_open())
  ------------------
  |  Branch (930:7): [True: 0, False: 1.12k]
  ------------------
  931|      0|		{
  932|      0|			PCPP_LOG_ERROR("Failed to open file: " << 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]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  933|      0|			return false;
  934|      0|		}
  935|       |
  936|  1.12k|		m_NeedsSwap = false;
  937|  1.12k|		bool shouldWriteHeader = true;
  938|       |
  939|  1.12k|		if (appendMode)
  ------------------
  |  Branch (939:7): [True: 1.01k, False: 113]
  ------------------
  940|  1.01k|		{
  941|       |			// Using temporary to avoid modifying member variables in case of failure to read header
  942|  1.01k|			bool needsSwap = false;
  943|  1.01k|			FileTimestampPrecision precisionFromHeader;
  944|  1.01k|			pcap_file_header header;
  945|       |
  946|       |			// Position file pointer at the beginning of the file to read the header. Apparently there is no guarantee
  947|       |			// where the read file pointer will be initialized when opening in std::ios::app.
  948|  1.01k|			pcapFile.seekg(0, std::ios::beg);
  949|  1.01k|			auto status = readPcapHeader(pcapFile, header, precisionFromHeader, needsSwap);
  950|  1.01k|			switch (status)
  951|  1.01k|			{
  952|  1.01k|			case PcapReadHeaderStatus::Ok:
  ------------------
  |  Branch (952:4): [True: 1.01k, False: 0]
  ------------------
  953|  1.01k|			{
  954|       |				// We have a valid header
  955|  1.01k|				PCPP_LOG_DEBUG("Read existing pcap header file.");
  ------------------
  |  |  426|  1.01k|#	define PCPP_LOG_DEBUG(message) PCPP_LOG(pcpp::LogLevel::Debug, message)
  |  |  ------------------
  |  |  |  |  413|  1.01k|	do                                                                                                                 \
  |  |  |  |  414|  1.01k|	{                                                                                                                  \
  |  |  |  |  415|  1.01k|		auto& logger = pcpp::Logger::getInstance();                                                                    \
  |  |  |  |  416|  1.01k|		if (logger.shouldLog(level, LOG_MODULE))                                                                       \
  |  |  |  |  ------------------
  |  |  |  |  |  |    3|  1.01k|#define LOG_MODULE PcapLogModuleFileDevice
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (416:7): [True: 0, False: 1.01k]
  |  |  |  |  ------------------
  |  |  |  |  417|  1.01k|		{                                                                                                              \
  |  |  |  |  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|  1.01k|	} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (423:11): [Folded, False: 1.01k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  956|  1.01k|				shouldWriteHeader = false;
  957|  1.01k|				break;
  958|      0|			}
  959|      0|			case PcapReadHeaderStatus::NoData:
  ------------------
  |  Branch (959:4): [True: 0, False: 1.01k]
  ------------------
  960|      0|			{
  961|       |				// Empty file - proceed as if we are creating a new file
  962|      0|				if (pcapFile.bad())
  ------------------
  |  Branch (962:9): [True: 0, False: 0]
  ------------------
  963|      0|				{
  964|       |					// badbit errors are generally unrecoverable.
  965|      0|					PCPP_LOG_ERROR("Error reading pcap 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]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  966|      0|					return false;
  967|      0|				}
  968|       |
  969|      0|				PCPP_LOG_DEBUG("File is empty. A new pcap header will be written.");
  ------------------
  |  |  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]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  970|      0|				pcapFile.clear();  // Clear EOF or failbit state to allow writing
  971|      0|				shouldWriteHeader = true;
  972|      0|				break;
  973|      0|			}
  974|      0|			case PcapReadHeaderStatus::MalformedData:
  ------------------
  |  Branch (974:4): [True: 0, False: 1.01k]
  ------------------
  975|      0|			{
  976|      0|				PCPP_LOG_ERROR("Cannot read pcap file header. File may be malformed or not a pcap 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]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  977|      0|				return false;
  978|      0|			}
  979|      0|			case PcapReadHeaderStatus::UnsupportedFormat:
  ------------------
  |  Branch (979:4): [True: 0, False: 1.01k]
  ------------------
  980|      0|			{
  981|      0|				PCPP_LOG_ERROR("Cannot read pcap file header. Unsupported format or invalid magic number: 0x"
  ------------------
  |  |  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]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  982|      0|				               << std::hex << header.magic);
  983|      0|				return false;
  984|      0|			}
  985|      0|			default:
  ------------------
  |  Branch (985:4): [True: 0, False: 1.01k]
  ------------------
  986|      0|				throw std::logic_error("Unexpected PcapReadHeaderStatus value");
  987|  1.01k|			}
  988|       |
  989|       |			// If we have a header, validate that the file is compatible.
  990|  1.01k|			if (!shouldWriteHeader)
  ------------------
  |  Branch (990:8): [True: 1.01k, False: 0]
  ------------------
  991|  1.01k|			{
  992|  1.01k|				m_NeedsSwap = needsSwap;
  993|       |
  994|  1.01k|				if (precisionFromHeader != m_Precision)
  ------------------
  |  Branch (994:9): [True: 0, False: 1.01k]
  ------------------
  995|      0|				{
  996|      0|					PCPP_LOG_ERROR("Existing file precision (" + toString(precisionFromHeader) +
  ------------------
  |  |  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]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  997|      0|					               ") does not match the requested device precision (" + toString(m_Precision) + ")");
  998|      0|					return false;
  999|      0|				}
 1000|       |
 1001|  1.01k|				if (header.version_major != PCAP_MAJOR_VERSION || header.version_minor != PCAP_MINOR_VERSION)
  ------------------
  |  Branch (1001:9): [True: 0, False: 1.01k]
  |  Branch (1001:55): [True: 0, False: 1.01k]
  ------------------
 1002|      0|				{
 1003|      0|					PCPP_LOG_ERROR("Unsupported pcap file version");
  ------------------
  |  |  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]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1004|      0|					return false;
 1005|      0|				}
 1006|       |
 1007|  1.01k|				if (header.linktype != static_cast<uint32_t>(m_PcapLinkLayerType))
  ------------------
  |  Branch (1007:9): [True: 0, False: 1.01k]
  ------------------
 1008|      0|				{
 1009|      0|					PCPP_LOG_ERROR("Existing file link type does not match the requested device link type");
  ------------------
  |  |  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]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1010|      0|					return false;
 1011|      0|				}
 1012|       |
 1013|       |				// Move the file pointer to the end of the file for appending new packets
 1014|  1.01k|				pcapFile.seekg(0, std::ios::end);
 1015|  1.01k|			}
 1016|  1.01k|		}
 1017|       |
 1018|  1.12k|		if (shouldWriteHeader && !writeHeader(pcapFile, m_Precision, PCPP_MAX_PACKET_SIZE, m_PcapLinkLayerType))
  ------------------
  |  |  486|    113|#define PCPP_MAX_PACKET_SIZE 65536
  ------------------
  |  Branch (1018:7): [True: 113, False: 1.01k]
  |  Branch (1018:28): [True: 0, False: 113]
  ------------------
 1019|      0|		{
 1020|      0|			return false;
 1021|      0|		}
 1022|       |
 1023|  1.12k|		m_PcapFile = std::move(pcapFile);
 1024|  1.12k|		return true;
 1025|  1.12k|	}
_ZN4pcpp20PcapFileWriterDevice11writePacketERKNS_9RawPacketE:
 1028|  8.52k|	{
 1029|  8.52k|		if (!m_PcapFile.is_open())
  ------------------
  |  Branch (1029:7): [True: 0, False: 8.52k]
  ------------------
 1030|      0|		{
 1031|      0|			PCPP_LOG_ERROR("File is not open");
  ------------------
  |  |  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]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1032|      0|			return false;
 1033|      0|		}
 1034|       |
 1035|  8.52k|		if (packet.getLinkLayerType() != m_PcapLinkLayerType)
  ------------------
  |  Branch (1035:7): [True: 4.82k, False: 3.70k]
  ------------------
 1036|  4.82k|		{
 1037|  4.82k|			PCPP_LOG_ERROR("Cannot write a packet with a different link type");
  ------------------
  |  |  444|  4.82k|#	define PCPP_LOG_ERROR(message) PCPP_LOG(pcpp::LogLevel::Error, message)
  |  |  ------------------
  |  |  |  |  413|  4.82k|	do                                                                                                                 \
  |  |  |  |  414|  4.82k|	{                                                                                                                  \
  |  |  |  |  415|  4.82k|		auto& logger = pcpp::Logger::getInstance();                                                                    \
  |  |  |  |  416|  4.82k|		if (logger.shouldLog(level, LOG_MODULE))                                                                       \
  |  |  |  |  ------------------
  |  |  |  |  |  |    3|  4.82k|#define LOG_MODULE PcapLogModuleFileDevice
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (416:7): [True: 4.82k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  417|  4.82k|		{                                                                                                              \
  |  |  |  |  418|  4.82k|			auto ctx =                                                                                                 \
  |  |  |  |  419|  4.82k|			    logger.createLogContext(level, pcpp::LogSource(LOG_MODULE, PCAPPP_FILENAME, __FUNCTION__, __LINE__));  \
  |  |  |  |  ------------------
  |  |  |  |  |  |    3|  4.82k|#define LOG_MODULE PcapLogModuleFileDevice
  |  |  |  |  ------------------
  |  |  |  |               			    logger.createLogContext(level, pcpp::LogSource(LOG_MODULE, PCAPPP_FILENAME, __FUNCTION__, __LINE__));  \
  |  |  |  |  ------------------
  |  |  |  |  |  |   20|       |#	define PCAPPP_FILENAME __FILE_NAME__
  |  |  |  |  ------------------
  |  |  |  |  420|  4.82k|			(*ctx) << message;                                                                                         \
  |  |  |  |  421|  4.82k|			logger.emit(std::move(ctx));                                                                               \
  |  |  |  |  422|  4.82k|		}                                                                                                              \
  |  |  |  |  423|  4.82k|	} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (423:11): [Folded, False: 4.82k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1038|  4.82k|			reportPacketDropped();
 1039|  4.82k|			return false;
 1040|  4.82k|		}
 1041|       |
 1042|  3.70k|		if (!m_BpfWrapper.matches(packet))
  ------------------
  |  Branch (1042:7): [True: 0, False: 3.70k]
  ------------------
 1043|      0|		{
 1044|      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]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1045|      0|			return false;
 1046|      0|		}
 1047|       |
 1048|  3.70k|		packet_header packetHeader{};
 1049|  3.70k|		auto packetTimestamp = packet.getPacketTimeStamp();
 1050|  3.70k|		packetHeader.tv_sec = packetTimestamp.tv_sec;
 1051|  3.70k|		packetHeader.tv_usec = m_Precision == FileTimestampPrecision::Nanoseconds ? packetTimestamp.tv_nsec
  ------------------
  |  Branch (1051:26): [True: 0, False: 3.70k]
  ------------------
 1052|  3.70k|		                                                                          : packetTimestamp.tv_nsec / 1000;
 1053|  3.70k|		packetHeader.caplen = packet.getRawDataLen();
 1054|  3.70k|		packetHeader.len = packet.getFrameLength();
 1055|       |
 1056|  3.70k|		if (m_NeedsSwap)
  ------------------
  |  Branch (1056:7): [True: 0, False: 3.70k]
  ------------------
 1057|      0|		{
 1058|      0|			packetHeader.tv_sec = swap32(packetHeader.tv_sec);
 1059|      0|			packetHeader.tv_usec = swap32(packetHeader.tv_usec);
 1060|      0|			packetHeader.caplen = swap32(packetHeader.caplen);
 1061|      0|			packetHeader.len = swap32(packetHeader.len);
 1062|      0|		}
 1063|       |
 1064|  3.70k|		if (!m_PcapFile.write(reinterpret_cast<const char*>(&packetHeader), sizeof(packetHeader)))
  ------------------
  |  Branch (1064:7): [True: 0, False: 3.70k]
  ------------------
 1065|      0|		{
 1066|      0|			PCPP_LOG_ERROR("Cannot write the packet header to 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]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1067|      0|			reportPacketDropped();
 1068|      0|			return false;
 1069|      0|		}
 1070|       |
 1071|  3.70k|		if (!m_PcapFile.write(reinterpret_cast<const char*>(packet.getRawData()), packet.getRawDataLen()))
  ------------------
  |  Branch (1071:7): [True: 0, False: 3.70k]
  ------------------
 1072|      0|		{
 1073|      0|			PCPP_LOG_ERROR("Cannot write the packet to 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]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1074|      0|			reportPacketDropped();
 1075|      0|			return false;
 1076|      0|		}
 1077|       |
 1078|  3.70k|		reportPacketProcessed();
 1079|  3.70k|		return true;
 1080|  3.70k|	}
_ZN4pcpp20PcapFileWriterDevice5closeEv:
 1113|    371|	{
 1114|    371|		if (!m_PcapFile.is_open())
  ------------------
  |  Branch (1114:7): [True: 0, False: 371]
  ------------------
 1115|      0|		{
 1116|      0|			return;
 1117|      0|		}
 1118|       |
 1119|    371|		m_PcapFile.close();
 1120|    371|	}
_ZN4pcpp20PcapFileWriterDevice11writeHeaderERNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEENS_22FileTimestampPrecisionEjNS_13LinkLayerTypeE:
 1124|    226|	{
 1125|    226|		pcap_file_header header{ precision == FileTimestampPrecision::Microseconds ? TCPDUMP_MAGIC : NSEC_TCPDUMP_MAGIC,
  ------------------
  |  Branch (1125:28): [True: 226, Folded]
  ------------------
 1126|    226|			                     PCAP_MAJOR_VERSION,
 1127|    226|			                     PCAP_MINOR_VERSION,
 1128|    226|			                     0,
 1129|    226|			                     0,
 1130|    226|			                     snaplen,
 1131|    226|			                     static_cast<uint32_t>(linkType) };
 1132|       |
 1133|    226|		outStream.write(reinterpret_cast<const char*>(&header), sizeof(header));
 1134|       |
 1135|    226|		if (!outStream.good())
  ------------------
  |  Branch (1135:7): [True: 0, False: 226]
  ------------------
 1136|      0|		{
 1137|      0|			PCPP_LOG_ERROR("Error writing pcap header");
  ------------------
  |  |  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]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1138|      0|			return false;
 1139|      0|		}
 1140|       |
 1141|    226|		return true;
 1142|    226|	}
_ZN4pcpp22PcapNgFileReaderDeviceC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
 1153|  1.12k|	PcapNgFileReaderDevice::PcapNgFileReaderDevice(const std::string& fileName) : IFileReaderDevice(fileName)
 1154|  1.12k|	{
 1155|  1.12k|		m_LightPcapNg = nullptr;
 1156|  1.12k|	}
_ZN4pcpp22PcapNgFileReaderDevice4openEv:
 1159|  1.12k|	{
 1160|  1.12k|		resetStatisticCounters();
 1161|       |
 1162|  1.12k|		if (m_LightPcapNg != nullptr)
  ------------------
  |  Branch (1162:7): [True: 0, False: 1.12k]
  ------------------
 1163|      0|		{
 1164|      0|			PCPP_LOG_DEBUG("pcapng 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]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1165|      0|			return true;
 1166|      0|		}
 1167|       |
 1168|  1.12k|		m_LightPcapNg = toLightPcapNgHandle(light_pcapng_open_read(m_FileName.c_str(), LIGHT_FALSE));
 1169|  1.12k|		if (m_LightPcapNg == nullptr)
  ------------------
  |  Branch (1169:7): [True: 0, False: 1.12k]
  ------------------
 1170|      0|		{
 1171|      0|			PCPP_LOG_ERROR("Cannot open pcapng 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]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1172|      0|			return false;
 1173|      0|		}
 1174|       |
 1175|  1.12k|		PCPP_LOG_DEBUG("Successfully opened pcapng reader device for filename '" << m_FileName << "'");
  ------------------
  |  |  426|  1.12k|#	define PCPP_LOG_DEBUG(message) PCPP_LOG(pcpp::LogLevel::Debug, message)
  |  |  ------------------
  |  |  |  |  413|  1.12k|	do                                                                                                                 \
  |  |  |  |  414|  1.12k|	{                                                                                                                  \
  |  |  |  |  415|  1.12k|		auto& logger = pcpp::Logger::getInstance();                                                                    \
  |  |  |  |  416|  1.12k|		if (logger.shouldLog(level, LOG_MODULE))                                                                       \
  |  |  |  |  ------------------
  |  |  |  |  |  |    3|  1.12k|#define LOG_MODULE PcapLogModuleFileDevice
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (416:7): [True: 0, False: 1.12k]
  |  |  |  |  ------------------
  |  |  |  |  417|  1.12k|		{                                                                                                              \
  |  |  |  |  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|  1.12k|	} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (423:11): [Folded, False: 1.12k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1176|  1.12k|		return true;
 1177|  1.12k|	}
_ZN4pcpp22PcapNgFileReaderDevice13getNextPacketERNS_9RawPacketE:
 1185|  9.64k|	{
 1186|  9.64k|		return getNextPacketInternal(rawPacket, nullptr);
 1187|  9.64k|	}
_ZN4pcpp22PcapNgFileReaderDevice21getNextPacketInternalERNS_9RawPacketEPNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
 1190|  9.64k|	{
 1191|  9.64k|		if (m_LightPcapNg == nullptr)
  ------------------
  |  Branch (1191:7): [True: 0, False: 9.64k]
  ------------------
 1192|      0|		{
 1193|      0|			PCPP_LOG_ERROR("Pcapng file device '" << m_FileName << "' 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]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1194|      0|			return false;
 1195|      0|		}
 1196|       |
 1197|  9.64k|		light_packet_header pktHeader;
 1198|  9.64k|		const uint8_t* pktData = nullptr;
 1199|       |
 1200|  9.64k|		if (!light_get_next_packet(toLightPcapNgT(m_LightPcapNg), &pktHeader, &pktData))
  ------------------
  |  Branch (1200:7): [True: 1.12k, False: 8.52k]
  ------------------
 1201|  1.12k|		{
 1202|  1.12k|			PCPP_LOG_DEBUG("Packet could not be read. Probably end-of-file");
  ------------------
  |  |  426|  1.12k|#	define PCPP_LOG_DEBUG(message) PCPP_LOG(pcpp::LogLevel::Debug, message)
  |  |  ------------------
  |  |  |  |  413|  1.12k|	do                                                                                                                 \
  |  |  |  |  414|  1.12k|	{                                                                                                                  \
  |  |  |  |  415|  1.12k|		auto& logger = pcpp::Logger::getInstance();                                                                    \
  |  |  |  |  416|  1.12k|		if (logger.shouldLog(level, LOG_MODULE))                                                                       \
  |  |  |  |  ------------------
  |  |  |  |  |  |    3|  1.12k|#define LOG_MODULE PcapLogModuleFileDevice
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (416:7): [True: 0, False: 1.12k]
  |  |  |  |  ------------------
  |  |  |  |  417|  1.12k|		{                                                                                                              \
  |  |  |  |  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|  1.12k|	} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (423:11): [Folded, False: 1.12k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1203|  1.12k|			return false;
 1204|  1.12k|		}
 1205|       |
 1206|  8.52k|		while (!m_BpfWrapper.matches(pktData, pktHeader.captured_length, pktHeader.timestamp, pktHeader.data_link))
  ------------------
  |  Branch (1206:10): [True: 0, False: 8.52k]
  ------------------
 1207|      0|		{
 1208|      0|			if (!light_get_next_packet(toLightPcapNgT(m_LightPcapNg), &pktHeader, &pktData))
  ------------------
  |  Branch (1208:8): [True: 0, False: 0]
  ------------------
 1209|      0|			{
 1210|      0|				PCPP_LOG_DEBUG("Packet could not be read. Probably end-of-file");
  ------------------
  |  |  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]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1211|      0|				return false;
 1212|      0|			}
 1213|      0|		}
 1214|       |
 1215|  8.52k|		uint8_t* myPacketData = new uint8_t[pktHeader.captured_length];
 1216|  8.52k|		memcpy(myPacketData, pktData, pktHeader.captured_length);
 1217|  8.52k|		const LinkLayerType linkType = static_cast<LinkLayerType>(pktHeader.data_link);
 1218|  8.52k|		if (linkType == LinkLayerType::LINKTYPE_INVALID)
  ------------------
  |  Branch (1218:7): [True: 1.46k, False: 7.05k]
  ------------------
 1219|  1.46k|		{
 1220|  1.46k|			PCPP_LOG_ERROR("Link layer type of raw packet could not be determined");
  ------------------
  |  |  444|  1.46k|#	define PCPP_LOG_ERROR(message) PCPP_LOG(pcpp::LogLevel::Error, message)
  |  |  ------------------
  |  |  |  |  413|  1.46k|	do                                                                                                                 \
  |  |  |  |  414|  1.46k|	{                                                                                                                  \
  |  |  |  |  415|  1.46k|		auto& logger = pcpp::Logger::getInstance();                                                                    \
  |  |  |  |  416|  1.46k|		if (logger.shouldLog(level, LOG_MODULE))                                                                       \
  |  |  |  |  ------------------
  |  |  |  |  |  |    3|  1.46k|#define LOG_MODULE PcapLogModuleFileDevice
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (416:7): [True: 1.46k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  417|  1.46k|		{                                                                                                              \
  |  |  |  |  418|  1.46k|			auto ctx =                                                                                                 \
  |  |  |  |  419|  1.46k|			    logger.createLogContext(level, pcpp::LogSource(LOG_MODULE, PCAPPP_FILENAME, __FUNCTION__, __LINE__));  \
  |  |  |  |  ------------------
  |  |  |  |  |  |    3|  1.46k|#define LOG_MODULE PcapLogModuleFileDevice
  |  |  |  |  ------------------
  |  |  |  |               			    logger.createLogContext(level, pcpp::LogSource(LOG_MODULE, PCAPPP_FILENAME, __FUNCTION__, __LINE__));  \
  |  |  |  |  ------------------
  |  |  |  |  |  |   20|       |#	define PCAPPP_FILENAME __FILE_NAME__
  |  |  |  |  ------------------
  |  |  |  |  420|  1.46k|			(*ctx) << message;                                                                                         \
  |  |  |  |  421|  1.46k|			logger.emit(std::move(ctx));                                                                               \
  |  |  |  |  422|  1.46k|		}                                                                                                              \
  |  |  |  |  423|  1.46k|	} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (423:11): [Folded, False: 1.46k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1221|  1.46k|		}
 1222|       |
 1223|  8.52k|		if (!rawPacket.setRawData(myPacketData, pktHeader.captured_length, true, pktHeader.timestamp, linkType,
  ------------------
  |  Branch (1223:7): [True: 0, False: 8.52k]
  ------------------
 1224|  8.52k|		                          pktHeader.original_length))
 1225|      0|		{
 1226|      0|			PCPP_LOG_ERROR("Couldn't set data to raw packet");
  ------------------
  |  |  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]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1227|      0|			return false;
 1228|      0|		}
 1229|       |
 1230|  8.52k|		if (packetComment != nullptr)
  ------------------
  |  Branch (1230:7): [True: 0, False: 8.52k]
  ------------------
 1231|      0|		{
 1232|      0|			if (pktHeader.comment != nullptr && pktHeader.comment_length > 0)
  ------------------
  |  Branch (1232:8): [True: 0, False: 0]
  |  Branch (1232:40): [True: 0, False: 0]
  ------------------
 1233|      0|			{
 1234|      0|				packetComment->assign(pktHeader.comment, pktHeader.comment_length);
 1235|      0|			}
 1236|      0|			else
 1237|      0|			{
 1238|      0|				packetComment->clear();
 1239|      0|			}
 1240|      0|		}
 1241|       |
 1242|  8.52k|		reportPacketProcessed();
 1243|  8.52k|		return true;
 1244|  8.52k|	}
_ZN4pcpp22PcapNgFileReaderDevice5closeEv:
 1247|  1.12k|	{
 1248|  1.12k|		if (m_LightPcapNg == nullptr)
  ------------------
  |  Branch (1248:7): [True: 0, False: 1.12k]
  ------------------
 1249|      0|			return;
 1250|       |
 1251|  1.12k|		light_pcapng_close(toLightPcapNgT(m_LightPcapNg));
 1252|  1.12k|		m_LightPcapNg = nullptr;
 1253|       |
 1254|  1.12k|		PCPP_LOG_DEBUG("File reader closed for file '" << m_FileName << "'");
  ------------------
  |  |  426|  1.12k|#	define PCPP_LOG_DEBUG(message) PCPP_LOG(pcpp::LogLevel::Debug, message)
  |  |  ------------------
  |  |  |  |  413|  1.12k|	do                                                                                                                 \
  |  |  |  |  414|  1.12k|	{                                                                                                                  \
  |  |  |  |  415|  1.12k|		auto& logger = pcpp::Logger::getInstance();                                                                    \
  |  |  |  |  416|  1.12k|		if (logger.shouldLog(level, LOG_MODULE))                                                                       \
  |  |  |  |  ------------------
  |  |  |  |  |  |    3|  1.12k|#define LOG_MODULE PcapLogModuleFileDevice
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (416:7): [True: 0, False: 1.12k]
  |  |  |  |  ------------------
  |  |  |  |  417|  1.12k|		{                                                                                                              \
  |  |  |  |  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|  1.12k|	} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (423:11): [Folded, False: 1.12k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1255|  1.12k|	}
PcapFileDevice.cpp:_ZN4pcpp12_GLOBAL__N_115detectPcapMagicEjPNS0_13FileByteOrderE:
  286|  1.01k|		{
  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|  1.01k|			constexpr std::array<uint32_t, 6> pcapMagicNumbers = {
  292|  1.01k|				TCPDUMP_MAGIC,          // 0xa1'b2'c3'd4 - regular pcap, microsecond-precision
  293|  1.01k|				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|  1.01k|				KUZNETZOV_TCPDUMP_MAGIC,          // Alexey Kuznetzov's modified libpcap format
  297|  1.01k|				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|  1.01k|				NSEC_TCPDUMP_MAGIC,          // 0xa1'b2'3c'4d - regular pcap, nanosecond-precision
  300|  1.01k|				NSEC_TCPDUMP_MAGIC_SWAPPED,  // 0x4d'3c'b2'a1 - regular pcap, nanosecond-precision (byte-swapped)
  301|  1.01k|			};
  302|       |
  303|  1.01k|			auto it = std::find(pcapMagicNumbers.begin(), pcapMagicNumbers.end(), magic);
  304|  1.01k|			if (it == pcapMagicNumbers.end())
  ------------------
  |  Branch (304:8): [True: 0, False: 1.01k]
  ------------------
  305|      0|			{
  306|      0|				return FileFormat::Unknown;
  307|      0|			}
  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|  1.01k|			auto const selectedIdx = std::distance(pcapMagicNumbers.begin(), it);
  313|       |
  314|  1.01k|			if (byteOrder != nullptr)
  ------------------
  |  Branch (314:8): [True: 1.01k, False: 0]
  ------------------
  315|  1.01k|			{
  316|  1.01k|				*byteOrder = (selectedIdx % 2 == 0) ? FileByteOrder::Native : FileByteOrder::Swapped;
  ------------------
  |  Branch (316:18): [True: 1.01k, False: 0]
  ------------------
  317|  1.01k|			}
  318|       |
  319|  1.01k|			if (selectedIdx < 2)
  ------------------
  |  Branch (319:8): [True: 1.01k, False: 0]
  ------------------
  320|  1.01k|			{
  321|  1.01k|				return FileFormat::Pcap;
  322|  1.01k|			}
  323|      0|			if (selectedIdx < 4)
  ------------------
  |  Branch (323:8): [True: 0, False: 0]
  ------------------
  324|      0|			{
  325|      0|				return FileFormat::PcapMod;
  326|      0|			}
  327|       |
  328|      0|			return FileFormat::PcapNano;
  329|      0|		}
PcapFileDevice.cpp:_ZN4pcpp12_GLOBAL__N_114readPcapHeaderERNSt3__113basic_istreamIcNS1_11char_traitsIcEEEERNS0_16pcap_file_headerERNS_22FileTimestampPrecisionERb:
  670|  1.01k|		{
  671|  1.01k|			inStream.read(reinterpret_cast<char*>(&header), sizeof(header));
  672|       |
  673|  1.01k|			auto readBytes = inStream.gcount();
  674|  1.01k|			if (readBytes == 0)
  ------------------
  |  Branch (674:8): [True: 0, False: 1.01k]
  ------------------
  675|      0|			{
  676|      0|				return PcapReadHeaderStatus::NoData;
  677|      0|			}
  678|  1.01k|			if (readBytes < static_cast<std::streamsize>(sizeof(header)))
  ------------------
  |  Branch (678:8): [True: 0, False: 1.01k]
  ------------------
  679|      0|			{
  680|      0|				return PcapReadHeaderStatus::MalformedData;
  681|      0|			}
  682|       |
  683|  1.01k|			FileByteOrder byteOrder;
  684|  1.01k|			FileFormat pcapFormat = detectPcapMagic(header.magic, &byteOrder);
  685|  1.01k|			if (pcapFormat == FileFormat::Unknown)
  ------------------
  |  Branch (685:8): [True: 0, False: 1.01k]
  ------------------
  686|      0|			{
  687|      0|				return PcapReadHeaderStatus::UnsupportedFormat;
  688|      0|			}
  689|       |
  690|  1.01k|			precision = getPcapPrecision(pcapFormat);
  691|  1.01k|			needsSwap = byteOrder == FileByteOrder::Swapped;
  692|       |
  693|  1.01k|			if (needsSwap)
  ------------------
  |  Branch (693:8): [True: 0, False: 1.01k]
  ------------------
  694|      0|			{
  695|      0|				header.magic = swap32(header.magic);
  696|      0|				header.version_major = swap16(header.version_major);
  697|      0|				header.version_minor = swap16(header.version_minor);
  698|      0|				header.thiszone = swap32(header.thiszone);
  699|      0|				header.sigfigs = swap32(header.sigfigs);
  700|      0|				header.snaplen = swap32(header.snaplen);
  701|      0|				header.linktype = swap32(header.linktype);
  702|      0|			}
  703|       |
  704|  1.01k|			return PcapReadHeaderStatus::Ok;
  705|  1.01k|		}
PcapFileDevice.cpp:_ZN4pcpp12_GLOBAL__N_116getPcapPrecisionENS0_10FileFormatE:
  462|  1.01k|		{
  463|  1.01k|			switch (format)
  464|  1.01k|			{
  465|  1.01k|			case FileFormat::Pcap:
  ------------------
  |  Branch (465:4): [True: 1.01k, False: 0]
  ------------------
  466|  1.01k|			case FileFormat::PcapMod:
  ------------------
  |  Branch (466:4): [True: 0, False: 1.01k]
  ------------------
  467|  1.01k|				return FileTimestampPrecision::Microseconds;
  468|      0|			case FileFormat::PcapNano:
  ------------------
  |  Branch (468:4): [True: 0, False: 1.01k]
  ------------------
  469|      0|				return FileTimestampPrecision::Nanoseconds;
  470|      0|			default:
  ------------------
  |  Branch (470:4): [True: 0, False: 1.01k]
  ------------------
  471|      0|				return FileTimestampPrecision::Unknown;
  472|  1.01k|			}
  473|  1.01k|		}
PcapFileDevice.cpp:_ZN4pcpp12_GLOBAL__N_119toLightPcapNgHandleEP15_light_pcapng_t:
   35|  1.12k|		{
   36|  1.12k|			return reinterpret_cast<internal::LightPcapNgHandle*>(pcapngHandle);
   37|  1.12k|		}
PcapFileDevice.cpp:_ZN4pcpp12_GLOBAL__N_114toLightPcapNgTEPNS_8internal17LightPcapNgHandleE:
   43|  10.7k|		{
   44|  10.7k|			return reinterpret_cast<light_pcapng_t*>(pcapngHandle);
   45|  10.7k|		}

_ZNK4pcpp16BpfFilterWrapper7matchesERKNS_9RawPacketE:
   96|  3.70k|	{
   97|  3.70k|		return matches(rawPacket.getRawData(), rawPacket.getRawDataLen(), rawPacket.getPacketTimeStamp(),
   98|  3.70k|		               rawPacket.getLinkLayerType());
   99|  3.70k|	}
_ZNK4pcpp16BpfFilterWrapper7matchesEPKhj8timespect:
  103|  12.2k|	{
  104|  12.2k|		if (m_FilterStr.empty())
  ------------------
  |  Branch (104:7): [True: 12.2k, False: 0]
  ------------------
  105|  12.2k|			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|  1.12k|{
    9|  1.12k|	FILE* fd;
   10|  1.12k|	int written = 0;
   11|       |
   12|  1.12k|	fd = fopen(path, "wb");
   13|  1.12k|	if (fd == nullptr)
  ------------------
  |  Branch (13:6): [True: 0, False: 1.12k]
  ------------------
   14|      0|	{
   15|      0|		std::cerr << "Error opening pcap file for writing\n";
   16|      0|		return -1;
   17|      0|	}
   18|       |
   19|  1.12k|	written = fwrite(data, 1, size, fd);
   20|  1.12k|	if (static_cast<size_t>(written) != size)
  ------------------
  |  Branch (20:6): [True: 0, False: 1.12k]
  ------------------
   21|      0|	{
   22|      0|		std::cerr << "Error writing pcap file\n";
   23|      0|		fclose(fd);
   24|      0|		return -1;
   25|      0|	}
   26|       |
   27|  1.12k|	fclose(fd);
   28|  1.12k|	return 0;
   29|  1.12k|}

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