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

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

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

_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|		}

_ZN4pcpp9RawPacketC2Ev:
  544|    152|		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|    152|	{
   23|    152|		RawPacket::clear();
   24|    152|	}
_ZN4pcpp9RawPacket10setRawDataEPKhib8timespecNS_13LinkLayerTypeEi:
   97|  1.21k|	{
   98|  1.21k|		return doSetRawData(pRawData, rawDataLen, takeOwnership, timestamp, layerType, frameLength);
   99|  1.21k|	}
_ZN4pcpp9RawPacket12doSetRawDataEPKhib8timespecNS_13LinkLayerTypeEi:
  103|  1.21k|	{
  104|  1.21k|		clear();
  105|       |
  106|  1.21k|		m_OwnsRawData = takeOwnership;
  107|  1.21k|		m_FrameLength = (frameLength == -1) ? rawDataLen : frameLength;
  ------------------
  |  Branch (107:19): [True: 221, False: 992]
  ------------------
  108|  1.21k|		m_RawData = (uint8_t*)pRawData;
  109|  1.21k|		m_RawDataLen = rawDataLen;
  110|  1.21k|		m_TimeStamp = timestamp;
  111|  1.21k|		m_RawPacketSet = true;
  112|  1.21k|		m_LinkLayerType = layerType;
  113|  1.21k|		return true;
  114|  1.21k|	}
_ZN4pcpp9RawPacket5clearEv:
  123|  1.36k|	{
  124|  1.36k|		if (m_RawData != nullptr && m_OwnsRawData)
  ------------------
  |  Branch (124:7): [True: 400, False: 965]
  |  Branch (124:31): [True: 400, False: 0]
  ------------------
  125|    400|			delete[] m_RawData;
  126|       |
  127|  1.36k|		m_RawData = nullptr;
  128|  1.36k|		m_RawDataLen = 0;
  129|  1.36k|		m_FrameLength = 0;
  130|  1.36k|		m_RawPacketSet = false;
  131|  1.36k|	}

_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|	}

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

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

_ZN4pcpp11IFileDevice21reportPacketProcessedEm:
   66|  1.21k|		{
   67|  1.21k|			m_NumOfPacketsProcessed += numPackets;
   68|  1.21k|		}
_ZN4pcpp21SnoopFileReaderDeviceC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  592|    389|		    : IFileReaderDevice(fileName), m_PcapLinkLayerType(LINKTYPE_ETHERNET)
  593|    389|		{}
_ZNK4pcpp21SnoopFileReaderDevice8isOpenedEv:
  622|  1.36k|		{
  623|  1.36k|			return m_SnoopFile.is_open();
  624|  1.36k|		}

_ZN4pcpp16BpfFilterWrapperC2Ev:
   93|    389|		BpfFilterWrapper() = default;

_ZN4pcpp11IFileDeviceC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  494|    389|	{
  495|    389|		m_FileName = fileName;
  496|    389|	}
_ZNK4pcpp11IFileDevice13getStatisticsERNS_9PcapStatsE:
  504|    152|	{
  505|    152|		PCPP_LOG_DEBUG("Statistics requested for file device for filename '" << m_FileName << "'");
  ------------------
  |  |  426|    152|#	define PCPP_LOG_DEBUG(message) PCPP_LOG(pcpp::LogLevel::Debug, message)
  |  |  ------------------
  |  |  |  |  413|    152|	do                                                                                                                 \
  |  |  |  |  414|    152|	{                                                                                                                  \
  |  |  |  |  415|    152|		auto& logger = pcpp::Logger::getInstance();                                                                    \
  |  |  |  |  416|    152|		if (logger.shouldLog(level, LOG_MODULE))                                                                       \
  |  |  |  |  ------------------
  |  |  |  |  |  |    3|    152|#define LOG_MODULE PcapLogModuleFileDevice
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (416:7): [True: 0, False: 152]
  |  |  |  |  ------------------
  |  |  |  |  417|    152|		{                                                                                                              \
  |  |  |  |  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|    152|	} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (423:11): [Folded, False: 152]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  506|    152|		stats.packetsRecv = m_NumOfPacketsProcessed;
  507|    152|		stats.packetsDrop = m_NumOfPacketsDropped;
  508|    152|		stats.packetsDropByInterface = 0;
  509|    152|	}
_ZN4pcpp11IFileDevice22resetStatisticCountersEv:
  512|    389|	{
  513|    389|		m_NumOfPacketsProcessed = 0;
  514|    389|		m_NumOfPacketsDropped = 0;
  515|    389|	}
_ZN4pcpp17IFileReaderDeviceC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  531|    389|	IFileReaderDevice::IFileReaderDevice(const std::string& fileName) : IFileDevice(fileName)
  532|    389|	{}
_ZN4pcpp17IFileReaderDevice9getReaderERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  535|    389|	{
  536|    389|		const auto extensionPos = fileName.find_last_of('.');
  537|    389|		const auto fileExtension = extensionPos != std::string::npos ? fileName.substr(extensionPos) : "";
  ------------------
  |  Branch (537:30): [True: 389, False: 0]
  ------------------
  538|       |
  539|    389|		if (fileExtension == ".pcapng" || fileExtension == ".zstd" || fileExtension == ".zst")
  ------------------
  |  Branch (539:7): [True: 0, False: 389]
  |  Branch (539:37): [True: 0, False: 389]
  |  Branch (539:65): [True: 0, False: 389]
  ------------------
  540|      0|			return new PcapNgFileReaderDevice(fileName);
  541|    389|		else if (fileExtension == ".snoop")
  ------------------
  |  Branch (541:12): [True: 389, False: 0]
  ------------------
  542|    389|			return new SnoopFileReaderDevice(fileName);
  543|       |
  544|      0|		return new PcapFileReaderDevice(fileName);
  545|    389|	}
_ZN4pcpp17IFileReaderDevice14getNextPacketsERNS_13PointerVectorINS_9RawPacketENSt3__114default_deleteIS2_EEEEi:
  606|    152|	{
  607|    152|		int numOfPacketsRead = 0;
  608|       |
  609|    249|		for (; numOfPacketsToRead < 0 || numOfPacketsRead < numOfPacketsToRead; numOfPacketsRead++)
  ------------------
  |  Branch (609:10): [True: 0, False: 249]
  |  Branch (609:36): [True: 152, False: 97]
  ------------------
  610|    152|		{
  611|    152|			RawPacket* newPacket = new RawPacket();
  612|    152|			bool packetRead = getNextPacket(*newPacket);
  613|    152|			if (packetRead)
  ------------------
  |  Branch (613:8): [True: 97, False: 55]
  ------------------
  614|     97|			{
  615|     97|				packetVec.pushBack(newPacket);
  616|     97|			}
  617|     55|			else
  618|     55|			{
  619|     55|				delete newPacket;
  620|     55|				break;
  621|     55|			}
  622|    152|		}
  623|       |
  624|    152|		return numOfPacketsRead;
  625|    152|	}
_ZN4pcpp21SnoopFileReaderDeviceD2Ev:
 1497|    389|	{
 1498|    389|		m_SnoopFile.close();
 1499|    389|	}
_ZN4pcpp21SnoopFileReaderDevice4openEv:
 1502|    389|	{
 1503|    389|		if (m_SnoopFile.is_open())
  ------------------
  |  Branch (1503:7): [True: 0, False: 389]
  ------------------
 1504|      0|		{
 1505|      0|			PCPP_LOG_ERROR("File already 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]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1506|      0|			return false;
 1507|      0|		}
 1508|       |
 1509|    389|		resetStatisticCounters();
 1510|       |
 1511|    389|		std::ifstream snoopFile;
 1512|    389|		snoopFile.open(m_FileName.c_str(), std::ifstream::binary);
 1513|    389|		if (!snoopFile.is_open())
  ------------------
  |  Branch (1513:7): [True: 0, False: 389]
  ------------------
 1514|      0|		{
 1515|      0|			PCPP_LOG_ERROR("Cannot open snoop 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]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1516|      0|			return false;
 1517|      0|		}
 1518|       |
 1519|    389|		snoop_file_header_t snoop_file_header;
 1520|    389|		snoopFile.read(reinterpret_cast<char*>(&snoop_file_header), sizeof(snoop_file_header_t));
 1521|    389|		if (!snoopFile)
  ------------------
  |  Branch (1521:7): [True: 2, False: 387]
  ------------------
 1522|      2|		{
 1523|      2|			PCPP_LOG_ERROR("Cannot read snoop file header for '" << m_FileName << "'");
  ------------------
  |  |  444|      2|#	define PCPP_LOG_ERROR(message) PCPP_LOG(pcpp::LogLevel::Error, message)
  |  |  ------------------
  |  |  |  |  413|      2|	do                                                                                                                 \
  |  |  |  |  414|      2|	{                                                                                                                  \
  |  |  |  |  415|      2|		auto& logger = pcpp::Logger::getInstance();                                                                    \
  |  |  |  |  416|      2|		if (logger.shouldLog(level, LOG_MODULE))                                                                       \
  |  |  |  |  ------------------
  |  |  |  |  |  |    3|      2|#define LOG_MODULE PcapLogModuleFileDevice
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (416:7): [True: 2, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  417|      2|		{                                                                                                              \
  |  |  |  |  418|      2|			auto ctx =                                                                                                 \
  |  |  |  |  419|      2|			    logger.createLogContext(level, pcpp::LogSource(LOG_MODULE, PCAPPP_FILENAME, __FUNCTION__, __LINE__));  \
  |  |  |  |  ------------------
  |  |  |  |  |  |    3|      2|#define LOG_MODULE PcapLogModuleFileDevice
  |  |  |  |  ------------------
  |  |  |  |               			    logger.createLogContext(level, pcpp::LogSource(LOG_MODULE, PCAPPP_FILENAME, __FUNCTION__, __LINE__));  \
  |  |  |  |  ------------------
  |  |  |  |  |  |   20|       |#	define PCAPPP_FILENAME __FILE_NAME__
  |  |  |  |  ------------------
  |  |  |  |  420|      2|			(*ctx) << message;                                                                                         \
  |  |  |  |  421|      2|			logger.emit(std::move(ctx));                                                                               \
  |  |  |  |  422|      2|		}                                                                                                              \
  |  |  |  |  423|      2|	} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (423:11): [Folded, False: 2]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1524|      2|			return false;
 1525|      2|		}
 1526|       |
 1527|    387|		if (!isSnoopMagic(snoop_file_header.identification_pattern))
  ------------------
  |  Branch (1527:7): [True: 156, False: 231]
  ------------------
 1528|    156|		{
 1529|    156|			PCPP_LOG_ERROR("File content does not match snoop magic number for file: \'" << m_FileName << '\'');
  ------------------
  |  |  444|    156|#	define PCPP_LOG_ERROR(message) PCPP_LOG(pcpp::LogLevel::Error, message)
  |  |  ------------------
  |  |  |  |  413|    156|	do                                                                                                                 \
  |  |  |  |  414|    156|	{                                                                                                                  \
  |  |  |  |  415|    156|		auto& logger = pcpp::Logger::getInstance();                                                                    \
  |  |  |  |  416|    156|		if (logger.shouldLog(level, LOG_MODULE))                                                                       \
  |  |  |  |  ------------------
  |  |  |  |  |  |    3|    156|#define LOG_MODULE PcapLogModuleFileDevice
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (416:7): [True: 156, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  417|    156|		{                                                                                                              \
  |  |  |  |  418|    156|			auto ctx =                                                                                                 \
  |  |  |  |  419|    156|			    logger.createLogContext(level, pcpp::LogSource(LOG_MODULE, PCAPPP_FILENAME, __FUNCTION__, __LINE__));  \
  |  |  |  |  ------------------
  |  |  |  |  |  |    3|    156|#define LOG_MODULE PcapLogModuleFileDevice
  |  |  |  |  ------------------
  |  |  |  |               			    logger.createLogContext(level, pcpp::LogSource(LOG_MODULE, PCAPPP_FILENAME, __FUNCTION__, __LINE__));  \
  |  |  |  |  ------------------
  |  |  |  |  |  |   20|       |#	define PCAPPP_FILENAME __FILE_NAME__
  |  |  |  |  ------------------
  |  |  |  |  420|    156|			(*ctx) << message;                                                                                         \
  |  |  |  |  421|    156|			logger.emit(std::move(ctx));                                                                               \
  |  |  |  |  422|    156|		}                                                                                                              \
  |  |  |  |  423|    156|	} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (423:11): [Folded, False: 156]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1530|    156|			return false;
 1531|    156|		}
 1532|       |
 1533|    231|		if (be32toh(snoop_file_header.version_number) != 2)
  ------------------
  |  Branch (1533:7): [True: 42, False: 189]
  ------------------
 1534|     42|		{
 1535|     42|			PCPP_LOG_ERROR("Malformed snoop file header version number for '" << m_FileName << "'");
  ------------------
  |  |  444|     42|#	define PCPP_LOG_ERROR(message) PCPP_LOG(pcpp::LogLevel::Error, message)
  |  |  ------------------
  |  |  |  |  413|     42|	do                                                                                                                 \
  |  |  |  |  414|     42|	{                                                                                                                  \
  |  |  |  |  415|     42|		auto& logger = pcpp::Logger::getInstance();                                                                    \
  |  |  |  |  416|     42|		if (logger.shouldLog(level, LOG_MODULE))                                                                       \
  |  |  |  |  ------------------
  |  |  |  |  |  |    3|     42|#define LOG_MODULE PcapLogModuleFileDevice
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (416:7): [True: 42, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  417|     42|		{                                                                                                              \
  |  |  |  |  418|     42|			auto ctx =                                                                                                 \
  |  |  |  |  419|     42|			    logger.createLogContext(level, pcpp::LogSource(LOG_MODULE, PCAPPP_FILENAME, __FUNCTION__, __LINE__));  \
  |  |  |  |  ------------------
  |  |  |  |  |  |    3|     42|#define LOG_MODULE PcapLogModuleFileDevice
  |  |  |  |  ------------------
  |  |  |  |               			    logger.createLogContext(level, pcpp::LogSource(LOG_MODULE, PCAPPP_FILENAME, __FUNCTION__, __LINE__));  \
  |  |  |  |  ------------------
  |  |  |  |  |  |   20|       |#	define PCAPPP_FILENAME __FILE_NAME__
  |  |  |  |  ------------------
  |  |  |  |  420|     42|			(*ctx) << message;                                                                                         \
  |  |  |  |  421|     42|			logger.emit(std::move(ctx));                                                                               \
  |  |  |  |  422|     42|		}                                                                                                              \
  |  |  |  |  423|     42|	} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (423:11): [Folded, False: 42]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1536|     42|			return false;
 1537|     42|		}
 1538|       |
 1539|       |		// From https://datatracker.ietf.org/doc/html/rfc1761
 1540|    189|		static const pcpp::LinkLayerType snoop_encap[] = {
 1541|    189|			LINKTYPE_ETHERNET,   /// IEEE 802.3
 1542|    189|			LINKTYPE_NULL,       /// IEEE 802.4 Token Bus
 1543|    189|			LINKTYPE_IEEE802_5,  /// IEEE 802.5
 1544|    189|			LINKTYPE_NULL,       /// IEEE 802.6 Metro Net
 1545|    189|			LINKTYPE_ETHERNET,   /// Ethernet
 1546|    189|			LINKTYPE_C_HDLC,     /// HDLC
 1547|    189|			LINKTYPE_NULL,       /// Character Synchronous, e.g. bisync
 1548|    189|			LINKTYPE_NULL,       /// IBM Channel-to-Channel
 1549|    189|			LINKTYPE_FDDI        /// FDDI
 1550|    189|		};
 1551|    189|		uint32_t datalink_type = be32toh(snoop_file_header.datalink_type);
 1552|    189|		if (datalink_type > ARRAY_SIZE(snoop_encap) - 1)
  ------------------
  |  Branch (1552:7): [True: 37, False: 152]
  ------------------
 1553|     37|		{
 1554|     37|			PCPP_LOG_ERROR("Cannot read data link type for '" << m_FileName << "'");
  ------------------
  |  |  444|     37|#	define PCPP_LOG_ERROR(message) PCPP_LOG(pcpp::LogLevel::Error, message)
  |  |  ------------------
  |  |  |  |  413|     37|	do                                                                                                                 \
  |  |  |  |  414|     37|	{                                                                                                                  \
  |  |  |  |  415|     37|		auto& logger = pcpp::Logger::getInstance();                                                                    \
  |  |  |  |  416|     37|		if (logger.shouldLog(level, LOG_MODULE))                                                                       \
  |  |  |  |  ------------------
  |  |  |  |  |  |    3|     37|#define LOG_MODULE PcapLogModuleFileDevice
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (416:7): [True: 37, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  417|     37|		{                                                                                                              \
  |  |  |  |  418|     37|			auto ctx =                                                                                                 \
  |  |  |  |  419|     37|			    logger.createLogContext(level, pcpp::LogSource(LOG_MODULE, PCAPPP_FILENAME, __FUNCTION__, __LINE__));  \
  |  |  |  |  ------------------
  |  |  |  |  |  |    3|     37|#define LOG_MODULE PcapLogModuleFileDevice
  |  |  |  |  ------------------
  |  |  |  |               			    logger.createLogContext(level, pcpp::LogSource(LOG_MODULE, PCAPPP_FILENAME, __FUNCTION__, __LINE__));  \
  |  |  |  |  ------------------
  |  |  |  |  |  |   20|       |#	define PCAPPP_FILENAME __FILE_NAME__
  |  |  |  |  ------------------
  |  |  |  |  420|     37|			(*ctx) << message;                                                                                         \
  |  |  |  |  421|     37|			logger.emit(std::move(ctx));                                                                               \
  |  |  |  |  422|     37|		}                                                                                                              \
  |  |  |  |  423|     37|	} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (423:11): [Folded, False: 37]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1555|     37|			return false;
 1556|     37|		}
 1557|       |
 1558|    152|		m_SnoopFile = std::move(snoopFile);
 1559|    152|		m_PcapLinkLayerType = snoop_encap[datalink_type];
 1560|       |
 1561|    152|		constexpr uint32_t maxPacketLength = 15'000;
 1562|    152|		m_ReadBuffer.resize(maxPacketLength);
 1563|       |
 1564|    152|		PCPP_LOG_DEBUG("Successfully opened file reader device for filename '" << m_FileName << "'");
  ------------------
  |  |  426|    152|#	define PCPP_LOG_DEBUG(message) PCPP_LOG(pcpp::LogLevel::Debug, message)
  |  |  ------------------
  |  |  |  |  413|    152|	do                                                                                                                 \
  |  |  |  |  414|    152|	{                                                                                                                  \
  |  |  |  |  415|    152|		auto& logger = pcpp::Logger::getInstance();                                                                    \
  |  |  |  |  416|    152|		if (logger.shouldLog(level, LOG_MODULE))                                                                       \
  |  |  |  |  ------------------
  |  |  |  |  |  |    3|    152|#define LOG_MODULE PcapLogModuleFileDevice
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (416:7): [True: 0, False: 152]
  |  |  |  |  ------------------
  |  |  |  |  417|    152|		{                                                                                                              \
  |  |  |  |  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|    152|	} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (423:11): [Folded, False: 152]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1565|    152|		return true;
 1566|    189|	}
_ZN4pcpp21SnoopFileReaderDevice14readNextPacketER8timespecPhjRjS4_:
 1570|  1.36k|	{
 1571|  1.36k|		snoop_packet_header_t snoop_packet_header;
 1572|  1.36k|		m_SnoopFile.read(reinterpret_cast<char*>(&snoop_packet_header), sizeof(snoop_packet_header_t));
 1573|  1.36k|		if (!m_SnoopFile)
  ------------------
  |  Branch (1573:7): [True: 103, False: 1.26k]
  ------------------
 1574|    103|		{
 1575|    103|			PCPP_LOG_ERROR("Failed to read packet metadata");
  ------------------
  |  |  444|    103|#	define PCPP_LOG_ERROR(message) PCPP_LOG(pcpp::LogLevel::Error, message)
  |  |  ------------------
  |  |  |  |  413|    103|	do                                                                                                                 \
  |  |  |  |  414|    103|	{                                                                                                                  \
  |  |  |  |  415|    103|		auto& logger = pcpp::Logger::getInstance();                                                                    \
  |  |  |  |  416|    103|		if (logger.shouldLog(level, LOG_MODULE))                                                                       \
  |  |  |  |  ------------------
  |  |  |  |  |  |    3|    103|#define LOG_MODULE PcapLogModuleFileDevice
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (416:7): [True: 103, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  417|    103|		{                                                                                                              \
  |  |  |  |  418|    103|			auto ctx =                                                                                                 \
  |  |  |  |  419|    103|			    logger.createLogContext(level, pcpp::LogSource(LOG_MODULE, PCAPPP_FILENAME, __FUNCTION__, __LINE__));  \
  |  |  |  |  ------------------
  |  |  |  |  |  |    3|    103|#define LOG_MODULE PcapLogModuleFileDevice
  |  |  |  |  ------------------
  |  |  |  |               			    logger.createLogContext(level, pcpp::LogSource(LOG_MODULE, PCAPPP_FILENAME, __FUNCTION__, __LINE__));  \
  |  |  |  |  ------------------
  |  |  |  |  |  |   20|       |#	define PCAPPP_FILENAME __FILE_NAME__
  |  |  |  |  ------------------
  |  |  |  |  420|    103|			(*ctx) << message;                                                                                         \
  |  |  |  |  421|    103|			logger.emit(std::move(ctx));                                                                               \
  |  |  |  |  422|    103|		}                                                                                                              \
  |  |  |  |  423|    103|	} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (423:11): [Folded, False: 103]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1576|    103|			return false;
 1577|    103|		}
 1578|       |
 1579|  1.26k|		capturedLength = be32toh(snoop_packet_header.included_length);
 1580|  1.26k|		if (capturedLength > packetDataLen)
  ------------------
  |  Branch (1580:7): [True: 48, False: 1.21k]
  ------------------
 1581|     48|		{
 1582|     48|			PCPP_LOG_ERROR("Packet length " << capturedLength << " is too large");
  ------------------
  |  |  444|     48|#	define PCPP_LOG_ERROR(message) PCPP_LOG(pcpp::LogLevel::Error, message)
  |  |  ------------------
  |  |  |  |  413|     48|	do                                                                                                                 \
  |  |  |  |  414|     48|	{                                                                                                                  \
  |  |  |  |  415|     48|		auto& logger = pcpp::Logger::getInstance();                                                                    \
  |  |  |  |  416|     48|		if (logger.shouldLog(level, LOG_MODULE))                                                                       \
  |  |  |  |  ------------------
  |  |  |  |  |  |    3|     48|#define LOG_MODULE PcapLogModuleFileDevice
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (416:7): [True: 48, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  417|     48|		{                                                                                                              \
  |  |  |  |  418|     48|			auto ctx =                                                                                                 \
  |  |  |  |  419|     48|			    logger.createLogContext(level, pcpp::LogSource(LOG_MODULE, PCAPPP_FILENAME, __FUNCTION__, __LINE__));  \
  |  |  |  |  ------------------
  |  |  |  |  |  |    3|     48|#define LOG_MODULE PcapLogModuleFileDevice
  |  |  |  |  ------------------
  |  |  |  |               			    logger.createLogContext(level, pcpp::LogSource(LOG_MODULE, PCAPPP_FILENAME, __FUNCTION__, __LINE__));  \
  |  |  |  |  ------------------
  |  |  |  |  |  |   20|       |#	define PCAPPP_FILENAME __FILE_NAME__
  |  |  |  |  ------------------
  |  |  |  |  420|     48|			(*ctx) << message;                                                                                         \
  |  |  |  |  421|     48|			logger.emit(std::move(ctx));                                                                               \
  |  |  |  |  422|     48|		}                                                                                                              \
  |  |  |  |  423|     48|	} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (423:11): [Folded, False: 48]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1583|     48|			return false;
 1584|     48|		}
 1585|       |
 1586|  1.21k|		m_SnoopFile.read(reinterpret_cast<char*>(packetData), capturedLength);
 1587|  1.21k|		if (!m_SnoopFile)
  ------------------
  |  Branch (1587:7): [True: 1, False: 1.21k]
  ------------------
 1588|      1|		{
 1589|      1|			PCPP_LOG_ERROR("Failed to read packet data");
  ------------------
  |  |  444|      1|#	define PCPP_LOG_ERROR(message) PCPP_LOG(pcpp::LogLevel::Error, message)
  |  |  ------------------
  |  |  |  |  413|      1|	do                                                                                                                 \
  |  |  |  |  414|      1|	{                                                                                                                  \
  |  |  |  |  415|      1|		auto& logger = pcpp::Logger::getInstance();                                                                    \
  |  |  |  |  416|      1|		if (logger.shouldLog(level, LOG_MODULE))                                                                       \
  |  |  |  |  ------------------
  |  |  |  |  |  |    3|      1|#define LOG_MODULE PcapLogModuleFileDevice
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (416:7): [True: 1, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  417|      1|		{                                                                                                              \
  |  |  |  |  418|      1|			auto ctx =                                                                                                 \
  |  |  |  |  419|      1|			    logger.createLogContext(level, pcpp::LogSource(LOG_MODULE, PCAPPP_FILENAME, __FUNCTION__, __LINE__));  \
  |  |  |  |  ------------------
  |  |  |  |  |  |    3|      1|#define LOG_MODULE PcapLogModuleFileDevice
  |  |  |  |  ------------------
  |  |  |  |               			    logger.createLogContext(level, pcpp::LogSource(LOG_MODULE, PCAPPP_FILENAME, __FUNCTION__, __LINE__));  \
  |  |  |  |  ------------------
  |  |  |  |  |  |   20|       |#	define PCAPPP_FILENAME __FILE_NAME__
  |  |  |  |  ------------------
  |  |  |  |  420|      1|			(*ctx) << message;                                                                                         \
  |  |  |  |  421|      1|			logger.emit(std::move(ctx));                                                                               \
  |  |  |  |  422|      1|		}                                                                                                              \
  |  |  |  |  423|      1|	} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (423:11): [Folded, False: 1]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1590|      1|			return false;
 1591|      1|		}
 1592|       |
 1593|  1.21k|		packetTimestamp = { static_cast<time_t>(be32toh(snoop_packet_header.time_sec)),
 1594|  1.21k|			                static_cast<long>(be32toh(snoop_packet_header.time_usec)) * 1000 };
 1595|       |
 1596|  1.21k|		frameLength = be32toh(snoop_packet_header.original_length);
 1597|       |
 1598|  1.21k|		auto pad = be32toh(snoop_packet_header.packet_record_length) -
 1599|  1.21k|		           (sizeof(snoop_packet_header_t) + be32toh(snoop_packet_header.included_length));
 1600|       |
 1601|  1.21k|		m_SnoopFile.ignore(pad);
 1602|       |
 1603|  1.21k|		return true;
 1604|  1.21k|	}
_ZN4pcpp21SnoopFileReaderDevice13getNextPacketERNS_9RawPacketE:
 1607|  1.36k|	{
 1608|  1.36k|		if (!isOpened())
  ------------------
  |  Branch (1608:7): [True: 0, False: 1.36k]
  ------------------
 1609|      0|		{
 1610|      0|			PCPP_LOG_ERROR("File device 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]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1611|      0|			return false;
 1612|      0|		}
 1613|       |
 1614|  1.36k|		timespec packetTimestamp{};
 1615|  1.36k|		uint32_t capturedLength = 0, frameLength = 0;
 1616|       |
 1617|  1.36k|		while (readNextPacket(packetTimestamp, m_ReadBuffer.data(), m_ReadBuffer.size(), capturedLength, frameLength))
  ------------------
  |  Branch (1617:10): [True: 1.21k, False: 152]
  ------------------
 1618|  1.21k|		{
 1619|  1.21k|			if (m_BpfWrapper.matches(m_ReadBuffer.data(), capturedLength, packetTimestamp, m_PcapLinkLayerType))
  ------------------
  |  Branch (1619:8): [True: 1.21k, False: 0]
  ------------------
 1620|  1.21k|			{
 1621|  1.21k|				auto packetData = std::make_unique<uint8_t[]>(capturedLength);
 1622|  1.21k|				std::copy(m_ReadBuffer.begin(), m_ReadBuffer.begin() + capturedLength, packetData.get());
 1623|       |
 1624|  1.21k|				rawPacket.setRawData(capturedLength > 0 ? packetData.release() : nullptr, capturedLength, true,
  ------------------
  |  Branch (1624:26): [True: 400, False: 813]
  ------------------
 1625|  1.21k|				                     packetTimestamp, m_PcapLinkLayerType, frameLength);
 1626|  1.21k|				reportPacketProcessed();
 1627|  1.21k|				return true;
 1628|  1.21k|			}
 1629|      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]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1630|      0|		}
 1631|       |
 1632|    152|		return false;
 1633|  1.36k|	}
_ZN4pcpp21SnoopFileReaderDevice5closeEv:
 1636|     97|	{
 1637|     97|		m_SnoopFile.close();
 1638|     97|		PCPP_LOG_DEBUG("File reader closed for file '" << m_FileName << "'");
  ------------------
  |  |  426|     97|#	define PCPP_LOG_DEBUG(message) PCPP_LOG(pcpp::LogLevel::Debug, message)
  |  |  ------------------
  |  |  |  |  413|     97|	do                                                                                                                 \
  |  |  |  |  414|     97|	{                                                                                                                  \
  |  |  |  |  415|     97|		auto& logger = pcpp::Logger::getInstance();                                                                    \
  |  |  |  |  416|     97|		if (logger.shouldLog(level, LOG_MODULE))                                                                       \
  |  |  |  |  ------------------
  |  |  |  |  |  |    3|     97|#define LOG_MODULE PcapLogModuleFileDevice
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (416:7): [True: 0, False: 97]
  |  |  |  |  ------------------
  |  |  |  |  417|     97|		{                                                                                                              \
  |  |  |  |  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|     97|	} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (423:11): [Folded, False: 97]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1639|     97|	}
PcapFileDevice.cpp:_ZN4pcpp12_GLOBAL__N_112isSnoopMagicEmPNS0_13FileByteOrderE:
  345|    387|		{
  346|    387|			constexpr std::array<uint64_t, 2> snoopMagicNumbers = {
  347|    387|				0x73'6E'6F'6F'70'00'00'00,  // snoop magic number, "snoop" in ASCII
  348|    387|				0x00'00'00'70'6F'6F'6E'73   // snoop magic number, "snoop" in ASCII (byte-swapped)
  349|    387|			};
  350|       |
  351|    387|			auto it = std::find(snoopMagicNumbers.begin(), snoopMagicNumbers.end(), magic);
  352|    387|			if (it == snoopMagicNumbers.end())
  ------------------
  |  Branch (352:8): [True: 156, False: 231]
  ------------------
  353|    156|			{
  354|    156|				return false;
  355|    156|			}
  356|       |
  357|    231|			if (byteOrder != nullptr)
  ------------------
  |  Branch (357:8): [True: 0, False: 231]
  ------------------
  358|      0|			{
  359|      0|				*byteOrder = (std::distance(snoopMagicNumbers.begin(), it) % 2 == 0) ? FileByteOrder::Native
  ------------------
  |  Branch (359:18): [True: 0, False: 0]
  ------------------
  360|      0|				                                                                     : FileByteOrder::Swapped;
  361|      0|			}
  362|       |
  363|    231|			return true;
  364|    387|		}
PcapFileDevice.cpp:_ZN4pcpp12_GLOBAL__N_110ARRAY_SIZEIKNS_13LinkLayerTypeELm9EEEmRAT0__T_:
   48|    189|		{
   49|    189|			return N;
   50|    189|		}

_ZNK4pcpp16BpfFilterWrapper7matchesEPKhj8timespect:
  103|  1.21k|	{
  104|  1.21k|		if (m_FilterStr.empty())
  ------------------
  |  Branch (104:7): [True: 1.21k, False: 0]
  ------------------
  105|  1.21k|			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|	}

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

LLVMFuzzerTestOneInput:
   11|    389|{
   12|    389|	if (tmpName.empty())
  ------------------
  |  Branch (12:6): [True: 1, False: 388]
  ------------------
   13|      1|		tmpName = tmpnam(nullptr);
   14|       |
   15|    389|	if (tmpFile.empty())
  ------------------
  |  Branch (15:6): [True: 1, False: 388]
  ------------------
   16|      1|		tmpFile = tmpName + FILE_EXT;
   17|       |
   18|    389|	if (dumpDataToPcapFile(data, size, tmpFile.c_str()) != 0)
  ------------------
  |  Branch (18:6): [True: 0, False: 389]
  ------------------
   19|      0|	{
   20|      0|		std::cerr << "Can't Dump buffer to the '" << tmpFile << "' file!!!!\n";
   21|      0|		return -1;
   22|      0|	}
   23|       |
   24|    389|	pcpp::Logger::getInstance().suppressLogs();
   25|       |
   26|    389|	std::unique_ptr<pcpp::IFileReaderDevice> reader(pcpp::IFileReaderDevice::getReader(tmpFile));
   27|    389|	if (!reader->open())
  ------------------
  |  Branch (27:6): [True: 237, False: 152]
  ------------------
   28|    237|	{
   29|    237|		std::cerr << "Error opening the '" << tmpFile << "' file\n";
   30|    237|		return -1;
   31|    237|	}
   32|       |
   33|    152|	pcpp::PcapStats stats;
   34|    152|	reader->getStatistics(stats);
   35|    152|	std::cout << "Read " << stats.packetsRecv << " packets successfully and " << stats.packetsDrop
   36|    152|	          << " packets could not be read" << std::endl;
   37|       |
   38|    152|	if (auto ngReader = dynamic_cast<pcpp::PcapNgFileReaderDevice*>(reader.get()))
  ------------------
  |  Branch (38:11): [True: 0, False: 152]
  ------------------
   39|      0|	{
   40|      0|		std::cout << "OS is '" << ngReader->getOS() << "'; Hardware is '" << ngReader->getHardware() << "'"
   41|      0|		          << "'; CaptureApplication is '" << ngReader->getCaptureApplication() << "'; CaptureFileComment is '"
   42|      0|		          << ngReader->getCaptureFileComment() << "'" << std::endl;
   43|      0|	}
   44|       |
   45|    152|	pcpp::RawPacketVector packets;
   46|    152|	if (reader->getNextPackets(packets, 1) != 1)
  ------------------
  |  Branch (46:6): [True: 55, False: 97]
  ------------------
   47|     55|	{
   48|     55|		std::cerr << "Couldn't read the first packet in the file\n";
   49|     55|		return 0;
   50|     55|	}
   51|       |
   52|     97|	pcpp::RawPacket& rawPacket = *packets.front();
   53|     97|	do
   54|  1.21k|	{
   55|       |		// go deeper only for .pcap and .pcapng format
   56|       |		// for .snoop we are only fuzzing the reader
   57|  1.21k|		if (0 == strcmp(FILE_EXT, ".pcap") || 0 == strcmp(FILE_EXT, ".pcapng"))
  ------------------
  |  Branch (57:7): [Folded, False: 0]
  |  Branch (57:41): [Folded, False: 0]
  ------------------
   58|      0|		{
   59|      0|			pcpp::Packet parsedPacket(&rawPacket);
   60|      0|			parsedPacket.toString();
   61|      0|			auto layer = parsedPacket.getFirstLayer();
   62|      0|			while (layer != nullptr)
  ------------------
  |  Branch (62:11): [True: 0, False: 0]
  ------------------
   63|      0|			{
   64|      0|				std::cout << layer->toString() << std::endl;
   65|      0|				layer->getHeaderLen();
   66|      0|				readParsedPacket(parsedPacket, layer);
   67|      0|				layer = layer->getNextLayer();
   68|      0|			}
   69|      0|			parsedPacket.computeCalculateFields();
   70|      0|		}
   71|  1.21k|	} while (reader->getNextPacket(rawPacket));
  ------------------
  |  Branch (71:11): [True: 1.11k, False: 97]
  ------------------
   72|       |
   73|     97|	reader->close();
   74|     97|	return 0;
   75|    152|}