<?xml version="1.0"?>
<doc>
    <assembly>
        <name>PcapDotNet.Base</name>
    </assembly>
    <members>
        <member name="T:PcapDotNet.Base.BitSequence">
            <summary>
            Useful functions for sequences of bits.
            </summary>
        </member>
        <member name="M:PcapDotNet.Base.BitSequence.ToByte(System.Boolean)">
            <summary>
            Casts a bit to a byte.
            True becomes 1 and false becomes 0.
            </summary>
            <param name="value">Bit 7 of the byte.</param>
            <returns>1 for true, 0 for false.</returns>
        </member>
        <member name="M:PcapDotNet.Base.BitSequence.Merge(System.Boolean,System.Boolean)">
            <summary>
            Merges 2 bits to a byte.
            Bits should be arranged from the most significant to the least.
            </summary>
            <param name="value1">Bit 6 of the byte.</param>
            <param name="value2">Bit 7 of the byte.</param>
            <returns>A byte with the 2 least significant bits determined by the input.</returns>
        </member>
        <member name="M:PcapDotNet.Base.BitSequence.Merge(System.Boolean,System.Boolean,System.Boolean)">
            <summary>
            Merges 3 bits to a byte.
            Bits should be arranged from the most significant to the least.
            </summary>
            <param name="value1">Bit 5 of the byte.</param>
            <param name="value2">Bit 6 of the byte.</param>
            <param name="value3">Bit 7 of the byte.</param>
            <returns>A byte with the 3 least significant bits determined by the input.</returns>
        </member>
        <member name="M:PcapDotNet.Base.BitSequence.Merge(System.Boolean,System.Boolean,System.Boolean,System.Boolean)">
            <summary>
            Merges 4 bits to a byte.
            Bits should be arranged from the most significant to the least.
            </summary>
            <param name="value1">Bit 4 of the byte.</param>
            <param name="value2">Bit 5 of the byte.</param>
            <param name="value3">Bit 6 of the byte.</param>
            <param name="value4">Bit 7 of the byte.</param>
            <returns>A byte with the 4 least significant bits determined by the input.</returns>
        </member>
        <member name="M:PcapDotNet.Base.BitSequence.Merge(System.Boolean,System.Boolean,System.Boolean,System.Boolean,System.Boolean)">
            <summary>
            Merges 5 bits to a byte.
            Bits should be arranged from the most significant to the least.
            </summary>
            <param name="value1">Bit 3 of the byte.</param>
            <param name="value2">Bit 4 of the byte.</param>
            <param name="value3">Bit 5 of the byte.</param>
            <param name="value4">Bit 6 of the byte.</param>
            <param name="value5">Bit 7 of the byte.</param>
            <returns>A byte with the 5 least significant bits determined by the input.</returns>
        </member>
        <member name="M:PcapDotNet.Base.BitSequence.Merge(System.Boolean,System.Boolean,System.Boolean,System.Boolean,System.Boolean,System.Boolean)">
            <summary>
            Merges 6 bits to a byte.
            Bits should be arranged from the most significant to the least.
            </summary>
            <param name="value1">Bit 2 of the byte.</param>
            <param name="value2">Bit 3 of the byte.</param>
            <param name="value3">Bit 4 of the byte.</param>
            <param name="value4">Bit 5 of the byte.</param>
            <param name="value5">Bit 6 of the byte.</param>
            <param name="value6">Bit 7 of the byte.</param>
            <returns>A byte with the 6 least significant bits determined by the input.</returns>
        </member>
        <member name="M:PcapDotNet.Base.BitSequence.Merge(System.Boolean,System.Boolean,System.Boolean,System.Boolean,System.Boolean,System.Boolean,System.Boolean)">
            <summary>
            Merges 7 bits to a byte.
            Bits should be arranged from the most significant to the least.
            </summary>
            <param name="value1">Bit 1 of the byte.</param>
            <param name="value2">Bit 2 of the byte.</param>
            <param name="value3">Bit 3 of the byte.</param>
            <param name="value4">Bit 4 of the byte.</param>
            <param name="value5">Bit 5 of the byte.</param>
            <param name="value6">Bit 6 of the byte.</param>
            <param name="value7">Bit 7 of the byte.</param>
            <returns>A byte with the 7 least significant bits determined by the input.</returns>
        </member>
        <member name="M:PcapDotNet.Base.BitSequence.Merge(System.Boolean,System.Boolean,System.Boolean,System.Boolean,System.Boolean,System.Boolean,System.Boolean,System.Boolean)">
            <summary>
            Merges 8 bits to a byte.
            Bits should be arranged from the most significant to the least.
            </summary>
            <param name="value1">Bit 0 of the byte.</param>
            <param name="value2">Bit 1 of the byte.</param>
            <param name="value3">Bit 2 of the byte.</param>
            <param name="value4">Bit 3 of the byte.</param>
            <param name="value5">Bit 4 of the byte.</param>
            <param name="value6">Bit 5 of the byte.</param>
            <param name="value7">Bit 6 of the byte.</param>
            <param name="value8">Bit 7 of the byte.</param>
            <returns>A byte whose bits are determined by the input.</returns>
        </member>
        <member name="M:PcapDotNet.Base.BitSequence.Merge(System.Byte,System.Byte)">
            <summary>
            Merges 2 bytes to a ushort.
            Bytes should be arranged from the most significant to the least.
            </summary>
            <param name="value1">Bits 0-7 of the ushort.</param>
            <param name="value2">Bits 8-15 of the ushort.</param>
            <returns>A ushort whose bits are determined by the input.</returns>
        </member>
        <member name="M:PcapDotNet.Base.BitSequence.Merge(System.Byte,System.Byte,System.Byte)">
            <summary>
            Merges 3 bytes to a UInt24.
            Bytes should be arranged from the most significant to the least.
            </summary>
            <param name="value1">Bits 0-7 of the UInt24.</param>
            <param name="value2">Bits 8-15 of the UInt24.</param>
            <param name="value3">Bits 16-23 of the UInt24.</param>
            <returns>A UInt24 whose bits are determined by the input.</returns>
        </member>
        <member name="M:PcapDotNet.Base.BitSequence.Merge(System.Byte,System.Byte,System.Byte,System.Byte)">
            <summary>
            Merges 4 bytes to a uint.
            Bytes should be arranged from the most significant to the least.
            </summary>
            <param name="value1">Bits 0-7 of the uint.</param>
            <param name="value2">Bits 8-15 of the uint.</param>
            <param name="value3">Bits 16-23 of the uint.</param>
            <param name="value4">Bits 24-31 of the uint.</param>
            <returns>A uint whose bits are determined by the input.</returns>
        </member>
        <member name="M:PcapDotNet.Base.BitSequence.Merge(System.Byte,System.Byte,System.Byte,System.Byte,System.Byte,System.Byte)">
            <summary>
            Merges 6 bytes to a UInt48.
            Bytes should be arranged from the most significant to the least.
            </summary>
            <param name="value1">Bits 0-7 of the UInt48.</param>
            <param name="value2">Bits 8-15 of the UInt48.</param>
            <param name="value3">Bits 16-23 of the UInt48.</param>
            <param name="value4">Bits 24-31 of the UInt48.</param>
            <param name="value5">Bits 32-39 of the UInt48.</param>
            <param name="value6">Bits 40-47 of the UInt48.</param>
            <returns>A UInt48 whose bits are determined by the input.</returns>
        </member>
        <member name="M:PcapDotNet.Base.BitSequence.Merge(System.Byte,System.Byte,System.Byte,System.Byte,System.Byte,System.Byte,System.Byte,System.Byte)">
            <summary>
            Merges 8 bytes to a ulong.
            Bytes should be arranged from the most significant to the least.
            </summary>
            <param name="value1">Bits 0-7 of the ulong.</param>
            <param name="value2">Bits 8-15 of the ulong.</param>
            <param name="value3">Bits 16-23 of the ulong.</param>
            <param name="value4">Bits 24-31 of the ulong.</param>
            <param name="value5">Bits 32-39 of the ulong.</param>
            <param name="value6">Bits 40-47 of the ulong.</param>
            <param name="value7">Bits 48-55 of the ulong.</param>
            <param name="value8">Bits 56-63 of the ulong.</param>
            <returns>A ulong whose bits are determined by the input.</returns>
        </member>
        <member name="M:PcapDotNet.Base.BitSequence.Merge(System.Byte,System.Byte,System.Byte,System.Byte,System.Byte,System.Byte,System.Byte,System.Byte,System.Byte,System.Byte,System.Byte,System.Byte,System.Byte,System.Byte,System.Byte,System.Byte)">
            <summary>
            Merges 16 bytes to a UInt128.
            Bytes should be arranged from the most significant to the least.
            </summary>
            <param name="value1">Bits 0-7 of the UInt128.</param>
            <param name="value2">Bits 8-15 of the UInt128.</param>
            <param name="value3">Bits 16-23 of the UInt128.</param>
            <param name="value4">Bits 24-31 of the UInt128.</param>
            <param name="value5">Bits 32-39 of the UInt128.</param>
            <param name="value6">Bits 40-47 of the UInt128.</param>
            <param name="value7">Bits 48-55 of the UInt128.</param>
            <param name="value8">Bits 56-63 of the UInt128.</param>
            <param name="value9">Bits 64-71 of the UInt128.</param>
            <param name="value10">Bits 72-79 of the UInt128.</param>
            <param name="value11">Bits 80-87 of the UInt128.</param>
            <param name="value12">Bits 88-95 of the UInt128.</param>
            <param name="value13">Bits 96-103 of the UInt128.</param>
            <param name="value14">Bits 104-111 of the UInt128.</param>
            <param name="value15">Bits 112-119 of the UInt128.</param>
            <param name="value16">Bits 120-127 of the UInt128.</param>
            <returns>A UInt128 whose bits are determined by the input.</returns>
        </member>
        <member name="M:PcapDotNet.Base.BitSequence.Merge(System.UInt16,System.UInt16)">
            <summary>
            Merges 2 ushort to a uint.
            ushorts should be arranged from the most significant to the least.
            </summary>
            <param name="value1">Bits 0-15 of the uint.</param>
            <param name="value2">Bits 16-31 of the uint.</param>
            <returns>A uint whose bits are determined by the input.</returns>
        </member>
        <member name="M:PcapDotNet.Base.BitSequence.Merge(System.Byte,System.UInt16)">
            <summary>
            Merges a byte and a ushort to a UInt24.
            Values should be arranged from the most significant to the least.
            </summary>
            <param name="value1">Bits 0-7 of the UInt24.</param>
            <param name="value2">Bits 8-23 of the UInt24.</param>
            <returns>A UInt24 whose bits are determined by the input.</returns>
        </member>
        <member name="M:PcapDotNet.Base.BitSequence.Merge(System.UInt16,System.Byte,System.Byte)">
            <summary>
            Merges a ushort and 2 bytes to a uint.
            Values should be arranged from the most significant to the least.
            </summary>
            <param name="value1">Bits 0-15 of the uint.</param>
            <param name="value2">Bits 16-23 of the uint.</param>
            <param name="value3">Bits 24-31 of the uint.</param>
            <returns>A uint whose bits are determined by the input.</returns>
        </member>
        <member name="M:PcapDotNet.Base.BitSequence.Merge(System.Byte,System.UInt16,System.Byte)">
            <summary>
            Merges a ushort and 2 bytes to a uint.
            Values should be arranged from the most significant to the least.
            </summary>
            <param name="value1">Bits 0-7 of the uint.</param>
            <param name="value2">Bits 8-23 of the uint.</param>
            <param name="value3">Bits 24-31 of the uint.</param>
            <returns>A uint whose bits are determined by the input.</returns>
        </member>
        <member name="M:PcapDotNet.Base.BitSequence.Merge(System.Byte,System.Byte,System.UInt16)">
            <summary>
            Merges a ushort and 2 bytes to a uint.
            Values should be arranged from the most significant to the least.
            </summary>
            <param name="value1">Bits 0-7 of the uint.</param>
            <param name="value2">Bits 8-15 of the uint.</param>
            <param name="value3">Bits 16-31 of the uint.</param>
            <returns>A uint whose bits are determined by the input.</returns>
        </member>
        <member name="M:PcapDotNet.Base.BitSequence.Merge(System.UInt32,System.UInt16,System.UInt16)">
            <summary>
            Merges a uint and 2 ushorts to a ulong.
            values should be arranged from the most significant to the least.
            </summary>
            <param name="value1">Bits 0-31 of the ulong.</param>
            <param name="value2">Bits 32-47 of the ulong.</param>
            <param name="value3">Bits 48-63 of the ulong.</param>
            <returns>A ulong whose bits are determined by the input.</returns>
        </member>
        <member name="M:PcapDotNet.Base.BitSequence.Merge(System.UInt32,System.UInt32)">
            <summary>
            Merges 2 uints to a ulong.
            uints should be arranged from the most significant to the least.
            </summary>
            <param name="value1">Bits 0-31 of the ulong.</param>
            <param name="value2">Bits 32-63 of the ulong.</param>
            <returns>A ulong whose bits are determined by the input.</returns>
        </member>
        <member name="M:PcapDotNet.Base.BitSequence.Merge(System.UInt64,System.UInt64)">
            <summary>
            Merges 2 ulongs to a UInt128.
            ulongs should be arranged from the most significant to the least.
            </summary>
            <param name="value1">Bits 0-63 of the UInt128.</param>
            <param name="value2">Bits 64-127 of the UInt128.</param>
            <returns>A UInt128 whose bits are determined by the input.</returns>
        </member>
        <member name="T:PcapDotNet.Base.CharExtensions">
            <summary>
            Extension methods for char structure.
            </summary>
        </member>
        <member name="M:PcapDotNet.Base.CharExtensions.IsUppercaseAlpha(System.Char)">
            <summary>
            True iff the given character is one of the capital english letters.
            </summary>
            <param name="character">The input character to check.</param>
            <returns>True for capital english letters.</returns>
        </member>
        <member name="T:PcapDotNet.Base.DateTimeExtensions">
            <summary>
            Extension methods for DateTime.
            </summary>
        </member>
        <member name="M:PcapDotNet.Base.DateTimeExtensions.AddMicroseconds(System.DateTime,System.Double)">
            <summary>
            Returns a new DateTime that adds the specified number of microseconds to the value of this instance.
            </summary>
            <param name="dateTime">The DateTime to add microseconds to.</param>
            <param name="value">A number of whole and fractional microseconds. The value parameter can be negative or positive. Note that this value is rounded to the nearest integer.</param>
            <returns>An object whose value is the sum of the date and time represented by this instance and the number of microseconds represented by value.</returns>
        </member>
        <member name="T:PcapDotNet.Base.EncodingExtensions">
            <summary>
            Extension methods for Encoding class.
            </summary>
        </member>
        <member name="P:PcapDotNet.Base.EncodingExtensions.Iso88591">
            <summary>
            ISO-8859-1 Encoding.
            </summary>
        </member>
        <member name="T:PcapDotNet.Base.FuncExtensions">
            <summary>
            Extension methods for Func of type T.
            </summary>
        </member>
        <member name="M:PcapDotNet.Base.FuncExtensions.GenerateArray``1(System.Func{``0},System.Int32)">
            <summary>
            Generates an array of a given size by generating elements using the given delegate.
            </summary>
            <typeparam name="T">The type of the array to create.</typeparam>
            <param name="generator">The delegate to generate elements with.</param>
            <param name="size">The size of the array to create.</param>
            <returns>An array of a given size with elements generated by the given delegate.</returns>
        </member>
        <member name="T:PcapDotNet.Base.IDictionaryExtensions">
            <summary>
            Extension methods for IDictionary&lt;TKey,TValue> interface.
            </summary>
        </member>
        <member name="M:PcapDotNet.Base.IDictionaryExtensions.DictionaryEquals``2(System.Collections.Generic.IDictionary{``0,``1},System.Collections.Generic.IDictionary{``0,``1},System.Collections.Generic.IEqualityComparer{``1})">
            <summary>
            Tests for equality between dictionaries.
            Two dictionaries are equal if they have the same pairs.
            Keys are compared using Equals() and values are compared using the given comparator.
            </summary>
            <typeparam name="TKey">The type of the key of the dictionary.</typeparam>
            <typeparam name="TValue">The type of the value of the dictionary.</typeparam>
            <param name="dictionary1">The first dictionary to compare.</param>
            <param name="dictionary2">The second dictionary to compare.</param>
            <param name="valueComparer">The comparator to check for values equality.</param>
            <returns>True iff the dictionaries are equal.</returns>
        </member>
        <member name="M:PcapDotNet.Base.IDictionaryExtensions.DictionaryEquals``2(System.Collections.Generic.IDictionary{``0,``1},System.Collections.Generic.IDictionary{``0,``1})">
            <summary>
            Tests for equality between dictionaries.
            Two dictionaries are equal if they have the same pairs.
            Keys are compared using Equals() and values are compared using the default EqualityComparer.
            </summary>
            <typeparam name="TKey">The type of the key of the dictionary.</typeparam>
            <typeparam name="TValue">The type of the value of the dictionary.</typeparam>
            <param name="dictionary1">The first dictionary to compare.</param>
            <param name="dictionary2">The second dictionary to compare.</param>
            <returns>True iff the dictionaries are equal.</returns>
        </member>
        <member name="T:PcapDotNet.Base.IEnumerableExtensions">
            <summary>
            Extension methods for IEnumerable of type T.
            </summary>
        </member>
        <member name="M:PcapDotNet.Base.IEnumerableExtensions.IsNullOrEmpty``1(System.Collections.Generic.IEnumerable{``0})">
            <summary>
            Returns true if the given enumerable is null or empty.
            </summary>
        </member>
        <member name="M:PcapDotNet.Base.IEnumerableExtensions.Concat``1(System.Collections.Generic.IEnumerable{``0},``0[])">
            <summary>
            Concatenates a sequence with more values.
            </summary>
            <typeparam name="T">The type of an element in the sequence.</typeparam>
            <param name="sequence">The sequence to concatenate.</param>
            <param name="values">The values that will be concatenated with the sequence.</param>
            <returns>A sequence containing all the original sequence elements cocatenated with values elements.</returns>
        </member>
        <member name="M:PcapDotNet.Base.IEnumerableExtensions.Xor(System.Collections.Generic.IEnumerable{System.Int64})">
            <summary>
            Returns the bitwise xor of all the elements in the sequence.
            </summary>
            <param name="sequence">The elements to xor.</param>
            <returns>The bitwise xor of all the elements in the sequence.</returns>
        </member>
        <member name="M:PcapDotNet.Base.IEnumerableExtensions.Xor(System.Collections.Generic.IEnumerable{System.Int32})">
            <summary>
            Returns the bitwise xor of all the elements in the sequence.
            </summary>
            <param name="sequence">The elements to xor.</param>
            <returns>The bitwise xor of all the elements in the sequence.</returns>
        </member>
        <member name="M:PcapDotNet.Base.IEnumerableExtensions.Xor``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Int64})">
            <summary>
            Returns the bitwise xor of all the selected values of the elements in the sequence.
            </summary>
            <param name="sequence">The elements to select values to xor.</param>
            <param name="selector">The selector used to select the values.</param>
            <returns>The bitwise xor of all the selected values of the elements in the sequence.</returns>
        </member>
        <member name="M:PcapDotNet.Base.IEnumerableExtensions.Xor``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Int32})">
            <summary>
            Returns the bitwise xor of all the selected values of the elements in the sequence.
            </summary>
            <param name="sequence">The elements to select values to xor.</param>
            <param name="selector">The selector used to select the values.</param>
            <returns>The bitwise xor of all the selected values of the elements in the sequence.</returns>
        </member>
        <member name="M:PcapDotNet.Base.IEnumerableExtensions.SequenceToString``1(System.Collections.Generic.IEnumerable{``0},System.String,System.String,System.String)">
            <summary>
            Converts a sequence to a string by converting each element to a string.
            </summary>
            <typeparam name="T">The type of an element in the sequence.</typeparam>
            <param name="sequence">The sequence with the elements to translate to string.</param>
            <param name="separator">A separator between the elements.</param>
            <param name="prefix">Prefix to the entire string.</param>
            <param name="suffix">Suffix to the entire string.</param>
            <returns>A string of all the elements.</returns>
        </member>
        <member name="M:PcapDotNet.Base.IEnumerableExtensions.SequenceToString``1(System.Collections.Generic.IEnumerable{``0},System.String,System.String)">
            <summary>
            Converts a sequence to a string by converting each element to a string.
            </summary>
            <typeparam name="T">The type of an element in the sequence.</typeparam>
            <param name="sequence">The sequence with the elements to translate to string.</param>
            <param name="separator">A separator between the elements.</param>
            <param name="prefix">Prefix to the entire string.</param>
            <returns>A string of all the elements.</returns>
        </member>
        <member name="M:PcapDotNet.Base.IEnumerableExtensions.SequenceToString``1(System.Collections.Generic.IEnumerable{``0},System.String)">
            <summary>
            Converts a sequence to a string by converting each element to a string.
            </summary>
            <typeparam name="T">The type of an element in the sequence.</typeparam>
            <param name="sequence">The sequence with the elements to translate to string.</param>
            <param name="separator">A separator between the elements.</param>
            <returns>A string of all the elements.</returns>
        </member>
        <member name="M:PcapDotNet.Base.IEnumerableExtensions.SequenceToString``1(System.Collections.Generic.IEnumerable{``0},System.Char)">
            <summary>
            Converts a sequence to a string by converting each element to a string.
            </summary>
            <typeparam name="T">The type of an element in the sequence.</typeparam>
            <param name="sequence">The sequence with the elements to translate to string.</param>
            <param name="separator">A separator between the elements.</param>
            <returns>A string of all the elements.</returns>
        </member>
        <member name="M:PcapDotNet.Base.IEnumerableExtensions.SequenceToString``1(System.Collections.Generic.IEnumerable{``0})">
            <summary>
            Converts a sequence to a string by converting each element to a string.
            </summary>
            <typeparam name="T">The type of an element in the sequence.</typeparam>
            <param name="sequence">The sequence with the elements to translate to string.</param>
            <returns>A string of all the elements.</returns>
        </member>
        <member name="M:PcapDotNet.Base.IEnumerableExtensions.BytesSequenceToHexadecimalString(System.Collections.Generic.IEnumerable{System.Byte},System.String)">
            <summary>
            Returns a string by converting all the bytes to a hexadecimal string.
            </summary>
            <param name="sequence">The bytes to convert to a string.</param>
            <param name="separator">The string to put between every two bytes.</param>
            <returns>The string resulted by converting all the bytes to hexadecimal strings and putting the separator between them.</returns>
        </member>
        <member name="M:PcapDotNet.Base.IEnumerableExtensions.BytesSequenceToHexadecimalString(System.Collections.Generic.IEnumerable{System.Byte})">
            <summary>
            Returns a string by converting all the bytes to a hexadecimal string.
            </summary>
            <param name="sequence">The bytes to convert to a string.</param>
            <returns>The string resulted by converting all the bytes to hexadecimal strings.</returns>
        </member>
        <member name="M:PcapDotNet.Base.IEnumerableExtensions.SequenceGetHashCode``1(System.Collections.Generic.IEnumerable{``0})">
            <summary>
            Creates a hash code by xoring the hash codes of the elements in the sequence.
            </summary>
            <typeparam name="T">The type of the elements in the sequence.</typeparam>
            <param name="sequence">The sequence with the elements to create the hash code for.</param>
            <returns>The hash code created by xoring all the hash codes of the elements in the sequence.</returns>
        </member>
        <member name="M:PcapDotNet.Base.IEnumerableExtensions.BytesSequenceGetHashCode(System.Collections.Generic.IEnumerable{System.Byte})">
            <summary>
            Returns a hash code by xoring all the bytes.
            Each byte is xored with the next 8 bits of the integer.
            </summary>
            <param name="sequence">The bytes to xor.</param>
            <returns>The hash code resulted by xoring all the bytes.</returns>
        </member>
        <member name="M:PcapDotNet.Base.IEnumerableExtensions.UShortsSequenceGetHashCode(System.Collections.Generic.IEnumerable{System.UInt16})">
            <summary>
            Returns a hash code by xoring all the ushorts.
            Each ushort is xored with the next 16 bits of the integer.
            </summary>
            <param name="sequence">The ushorts to xor.</param>
            <returns>The hash code resulted by xoring all the ushorts.</returns>
        </member>
        <member name="M:PcapDotNet.Base.IEnumerableExtensions.Count``1(System.Collections.Generic.IEnumerable{``0},``0)">
            <summary>
            Counts the number of types the given value is contained in the given sequence.
            </summary>
            <typeparam name="T">The type of the elements in the sequence.</typeparam>
            <param name="sequence">The sequence to look for the value in.</param>
            <param name="value">The value to look for in the sequence.</param>
            <returns>The number of types the given value is contained in the given sequence.</returns>
        </member>
        <member name="M:PcapDotNet.Base.IEnumerableExtensions.IsStrictOrdered``1(System.Collections.Generic.IEnumerable{``0})">
            <summary>
            Returns true iff the given sequence is strictly ordered using the elements as keys and a default comparer.
            </summary>
            <typeparam name="T">The type of the objects in the sequence that will be used as keys for comparison using a default comparer.</typeparam>
            <param name="sequence">The sequence of elements to check for strict order.</param>
            <returns>True iff the sequence is strictly ordered.</returns>
        </member>
        <member name="M:PcapDotNet.Base.IEnumerableExtensions.IsStrictOrdered``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1})">
            <summary>
            Returns true iff the given sequence is strictly ordered using the by keys computed using a given function and a default comparer.
            </summary>
            <typeparam name="T">
            The type of the objects in the sequence that will that will be operated with the given key selector function to get the keys
            to compare using a default comparer.
            </typeparam>
            <typeparam name="TKey">The type of the keys to compare using a default comparer.</typeparam>
            <param name="sequence">The sequence of elements to check for strict order.</param>
            <param name="keySelector">The function to operate on the sequence elements to get the keys to compare.</param>
            <returns>True iff the sequence is strictly ordered.</returns>
        </member>
        <member name="M:PcapDotNet.Base.IEnumerableExtensions.IsStrictOrdered``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IComparer{``1})">
            <summary>
            Returns true iff the given sequence is strictly ordered using the by keys computed using a given function and a given comparer.
            </summary>
            <typeparam name="T">
            The type of the objects in the sequence that will that will be operated with the given key selector function to get the keys
            to compare using a given comparer.
            </typeparam>
            <typeparam name="TKey">The type of the keys to compare using a given comparer.</typeparam>
            <param name="sequence">The sequence of elements to check for strict order.</param>
            <param name="keySelector">The function to operate on the sequence elements to get the keys to compare.</param>
            <param name="comparer">The comparer to use to compare the computed keys.</param>
            <returns>True iff the sequence is strictly ordered.</returns>
        </member>
        <member name="T:PcapDotNet.Base.IListExtensions">
            <summary>
            Extension methods for IList of type T.
            </summary>
        </member>
        <member name="M:PcapDotNet.Base.IListExtensions.AsReadOnly``1(System.Collections.Generic.IList{``0})">
            <summary>
            Wraps a list with a ReadOnlyCollection.
            </summary>
            <typeparam name="T">The type of an element in the collection.</typeparam>
            <param name="list">The list to wrap in a ReadOnlyCollection.</param>
            <returns></returns>
        </member>
        <member name="M:PcapDotNet.Base.IListExtensions.Range``1(System.Collections.Generic.IList{``0},System.Int32,System.Int32)">
            <summary>
            Returns an enumerable of all the elements in the given list starting in a specific offset and taking no more than a specific count.
            </summary>
            <typeparam name="T">The type of an element in the collection.</typeparam>
            <param name="list">The list to take the elements from.</param>
            <param name="offset">The offset of the first element to take.</param>
            <param name="count">The maximum number of elements to take.</param>
            <returns>An enumerable of all the elements in the given list starting in a specific offset and taking no more than a specific count.</returns>
        </member>
        <member name="T:PcapDotNet.Base.InlineEqualityComparer`1">
            <summary>
            An equality comparer that is implemented using the given equals and getHashCode functions.
            </summary>
            <typeparam name="T">The type of objects to compare.</typeparam>
        </member>
        <member name="M:PcapDotNet.Base.InlineEqualityComparer`1.#ctor(System.Func{`0,`0,System.Boolean},System.Func{`0,System.Int32})">
            <summary>
            Constructs the comparer using the given equals and getHashCode functions.
            </summary>
            <param name="equals">The function to use to implement Equals().</param>
            <param name="getHashCode">The function to use to implement GetHashCode().</param>
        </member>
        <member name="M:PcapDotNet.Base.InlineEqualityComparer`1.System#Collections#Generic#IEqualityComparer{T}#Equals(`0,`0)">
            <summary>
            Determines whether the specified objects are equal using the equals function that was given in the constructor.
            </summary>
            <returns>
            true if the specified objects are equal; otherwise, false.
            </returns>
            <param name="x">The first object of type <see cref="T:System.Object"/> to compare.</param><param name="y">The second object of type <see cref="T:System.Object"/> to compare.</param>
        </member>
        <member name="M:PcapDotNet.Base.InlineEqualityComparer`1.System#Collections#Generic#IEqualityComparer{T}#GetHashCode(`0)">
            <summary>
            Returns a hash code for the specified object using the getHashCode function that was given in the constructor.
            </summary>
            <returns>
            A hash code for the specified object.
            </returns>
            <param name="obj">The <see cref="T:System.Object"/> for which a hash code is to be returned.</param><exception cref="T:System.ArgumentNullException">The type of <paramref name="obj"/> is a reference type and <paramref name="obj"/> is null.</exception>
        </member>
        <member name="T:PcapDotNet.Base.MatchExtensions">
            <summary>
            Extension methods for Match class.
            </summary>
        </member>
        <member name="M:PcapDotNet.Base.MatchExtensions.GroupCapturesValues(System.Text.RegularExpressions.Match,System.String)">
            <summary>
            Returns all the values that were captured for a given group name.
            </summary>
            <param name="match">The match to take the captured values from.</param>
            <param name="groupName">The name of the capture group to take the values of.</param>
            <returns>All the values that were captured for a given group name.</returns>
        </member>
        <member name="T:PcapDotNet.Base.PropertyInfoExtensions">
            <summary>
            Extension methods for PropertyInfo.
            </summary>
        </member>
        <member name="M:PcapDotNet.Base.PropertyInfoExtensions.GetValue(System.Reflection.PropertyInfo,System.Object)">
            <summary>
            Returns the value of the given instance's non-indexed property.
            </summary>
        </member>
        <member name="T:PcapDotNet.Base.Sequence">
            <summary>
            Useful functions for a sequence of objects.
            </summary>
        </member>
        <member name="M:PcapDotNet.Base.Sequence.GetHashCode(System.Object,System.Object)">
            <summary>
            Returns the xor of the hash codes of the given objects.
            </summary>
        </member>
        <member name="M:PcapDotNet.Base.Sequence.GetHashCode(System.Object,System.Object,System.Object)">
            <summary>
            Returns the xor of the hash codes of the given objects.
            </summary>
        </member>
        <member name="M:PcapDotNet.Base.Sequence.GetHashCode(System.Object[])">
            <summary>
            Returns the xor of the hash codes of the given objects.
            </summary>
        </member>
        <member name="T:PcapDotNet.Base.SerialNumber32">
            <summary>
            A 32 bit serial number as defined in RFC 1982.
            </summary>
        </member>
        <member name="F:PcapDotNet.Base.SerialNumber32.SizeOf">
            <summary>
            The number of bytes this type takes.
            </summary>
        </member>
        <member name="F:PcapDotNet.Base.SerialNumber32.SerialBits">
            <summary>
            Number of bits of the serial number.
            </summary>
        </member>
        <member name="F:PcapDotNet.Base.SerialNumber32.MaxAdditiveNumber">
            <summary>
            The maximum value that can be added to the serial number.
            </summary>
        </member>
        <member name="M:PcapDotNet.Base.SerialNumber32.#ctor(System.UInt32)">
            <summary>
            Constructs a serial number from an unsigned value.
            </summary>
            <param name="value">The value to set the serial number.</param>
        </member>
        <member name="M:PcapDotNet.Base.SerialNumber32.Add(System.UInt32)">
            <summary>
            Adds a value to the serial number and returns the result.
            <paramref name="value"/> should not be bigger than <see cref="F:PcapDotNet.Base.SerialNumber32.MaxAdditiveNumber"/>.
            </summary>
            <param name="value">The value to add.</param>
            <returns>A new serial number that represents the sum of the original serial number and <paramref name="value"/>.</returns>
        </member>
        <member name="M:PcapDotNet.Base.SerialNumber32.Equals(PcapDotNet.Base.SerialNumber32)">
            <summary>
            Two serial numbers are equal if their value is equal.
            </summary>
            <param name="other">The object to compare to.</param>
            <returns>True iff the two serial numbers are equal.</returns>
        </member>
        <member name="M:PcapDotNet.Base.SerialNumber32.Equals(System.Object)">
            <summary>
            Two serial numbers are equal if their value is equal.
            </summary>
            <param name="obj">The object to compare to.</param>
            <returns>True iff the two serial numbers are equal.</returns>
        </member>
        <member name="M:PcapDotNet.Base.SerialNumber32.GetHashCode">
            <summary>
            Returns the hash code for this instance.
            </summary>
            <returns>A 32-bit signed integer that is the hash code for this instance.</returns>
        </member>
        <member name="M:PcapDotNet.Base.SerialNumber32.CompareTo(PcapDotNet.Base.SerialNumber32)">
            <summary>
            Compares the current object with another object of the same type.
            </summary>
            <returns>
            A value that indicates the relative order of the objects being compared.
            The return value has the following meanings:
            Value Meaning Less than zero This object is less than the <paramref name="other"/>.
            parameter.Zero This object is equal to <paramref name="other"/>.
            Greater than zero This object is greater than <paramref name="other"/>.
            </returns>
            <param name="other">An object to compare with this object.</param>
        </member>
        <member name="M:PcapDotNet.Base.SerialNumber32.ToString">
            <summary>
            The string representation of this serial number.
            </summary>
            <returns>A string representing this serial number.</returns>
        </member>
        <member name="M:PcapDotNet.Base.SerialNumber32.ToString(System.IFormatProvider)">
            <summary>
             The string representation of this serial number using the given format provider.
            </summary>
            <param name="provider">The format of the output string.</param>
            <returns>A string representing this serial number using the given format provider.</returns>
        </member>
        <member name="M:PcapDotNet.Base.SerialNumber32.op_Implicit(System.UInt32)~PcapDotNet.Base.SerialNumber32">
            <summary>
            Implicitly cast a uint to a serial number.
            </summary>
            <param name="value">The value to cast.</param>
            <returns>The casted value.</returns>
        </member>
        <member name="M:PcapDotNet.Base.SerialNumber32.op_Equality(PcapDotNet.Base.SerialNumber32,PcapDotNet.Base.SerialNumber32)">
            <summary>
            Returns true iff the two serial numbers are equal.
            </summary>
            <param name="value1">First serial number to compare.</param>
            <param name="value2">Second serial number to compare.</param>
            <returns>True iff the two serial numbers are equal.</returns>
        </member>
        <member name="M:PcapDotNet.Base.SerialNumber32.op_Inequality(PcapDotNet.Base.SerialNumber32,PcapDotNet.Base.SerialNumber32)">
            <summary>
            Returns true iff the two serial numbers are not equal.
            </summary>
            <param name="value1">First serial number to compare.</param>
            <param name="value2">Second serial number to compare.</param>
            <returns>True iff the two serial numbers are not equal.</returns>
        </member>
        <member name="M:PcapDotNet.Base.SerialNumber32.op_LessThan(PcapDotNet.Base.SerialNumber32,PcapDotNet.Base.SerialNumber32)">
            <summary>
            Returns true iff the first serial number is smaller than the second serial number.
            </summary>
            <param name="value1">First serial number to compare.</param>
            <param name="value2">Second serial number to compare.</param>
            <returns>True iff the first serial number is smaller than the second serial number..</returns>
        </member>
        <member name="M:PcapDotNet.Base.SerialNumber32.op_GreaterThan(PcapDotNet.Base.SerialNumber32,PcapDotNet.Base.SerialNumber32)">
            <summary>
            Returns true iff the first serial number is greater than the second serial number.
            </summary>
            <param name="value1">First serial number to compare.</param>
            <param name="value2">Second serial number to compare.</param>
            <returns>True iff the first serial number is greater than the second serial number..</returns>
        </member>
        <member name="P:PcapDotNet.Base.SerialNumber32.Value">
            <summary>
            The value of the serial number.
            </summary>
        </member>
        <member name="T:PcapDotNet.Base.ShortExtensions">
            <summary>
            Extension method for Short structure.
            </summary>
        </member>
        <member name="M:PcapDotNet.Base.ShortExtensions.ReverseEndianity(System.Int16)">
            <summary>
            Reverses the endianity of the given value.
            </summary>
        </member>
        <member name="T:PcapDotNet.Base.StringExtensions">
            <summary>
            Extension methods for String.
            </summary>
        </member>
        <member name="M:PcapDotNet.Base.StringExtensions.AreAllCharactersInRange(System.String,System.Char,System.Char)">
            <summary>
            Returns whether all of the chars in the given string are in the [minValue, maxValue] range.
            </summary>
            <param name="value">The string to test.</param>
            <param name="minValue">The first char in the chars range.</param>
            <param name="maxValue">The last char in the chars range.</param>
            <returns>True iff all of the string's chars are in the given range.</returns>
        </member>
        <member name="T:PcapDotNet.Base.TimeSpanExtensions">
            <summary>
            Extension methods for TimeSpan.
            </summary>
        </member>
        <member name="F:PcapDotNet.Base.TimeSpanExtensions.TicksPerMicrosecond">
            <summary>
            Represents the number of ticks in 1 microsecond. This field is constant.
            </summary>
        </member>
        <member name="M:PcapDotNet.Base.TimeSpanExtensions.Divide(System.TimeSpan,System.Double)">
            <summary>
            Divides the TimeSpan by a given value.
            </summary>
            <param name="timeSpan">The TimeSpan to divide.</param>
            <param name="value">The value to divide the TimeSpan by.</param>
            <returns>A TimeSpan value equals to the given TimeSpan divided by the given value.</returns>
        </member>
        <member name="M:PcapDotNet.Base.TimeSpanExtensions.Multiply(System.TimeSpan,System.Double)">
            <summary>
            Multiplies the TimeSpan by a given value.
            </summary>
            <param name="timeSpan">The TimeSpan to multiply.</param>
            <param name="value">The value to multiply the TimeSpan by.</param>
            <returns>A TimeSpan value equals to the given TimeSpan multiplied by the given value.</returns>
        </member>
        <member name="T:PcapDotNet.Base.TypeExtensions">
            <summary>
            Extension methods for Type.
            </summary>
        </member>
        <member name="M:PcapDotNet.Base.TypeExtensions.GetEnumValues``1(System.Type)">
            <summary>
            Returns all the possible values for the given enum type.
            </summary>
        </member>
        <member name="T:PcapDotNet.Base.UInt128">
            <summary>
            A 128 bit unsigned integer.
            </summary>
        </member>
        <member name="F:PcapDotNet.Base.UInt128.SizeOf">
            <summary>
            The number of bytes this type will take.
            </summary>
        </member>
        <member name="F:PcapDotNet.Base.UInt128.MinValue">
            <summary>
            The minimum UInt128 value.
            </summary>
        </member>
        <member name="F:PcapDotNet.Base.UInt128.MaxValue">
            <summary>
            The maximum value of this type.
            </summary>
        </member>
        <member name="F:PcapDotNet.Base.UInt128.Zero">
            <summary>
            A Zero UInt128 value.
            </summary>
        </member>
        <member name="F:PcapDotNet.Base.UInt128.One">
            <summary>
            A One UInt128 value.
            </summary>
        </member>
        <member name="M:PcapDotNet.Base.UInt128.#ctor(System.UInt64,System.UInt64)">
            <summary>
            Creates a value using two 64 bit values.
            </summary>
            <param name="mostSignificant">The most significant 64 bits of the value.</param>
            <param name="leastSignificant">The least significant 64 bits of the value.</param>
        </member>
        <member name="M:PcapDotNet.Base.UInt128.#ctor(System.Numerics.BigInteger)">
            <summary>
            Conversion of a <see cref="T:System.Numerics.BigInteger"/> object to an unsigned 128-bit integer value.
            </summary>
            <param name="value">The value to convert to an unsigned 128-bit integer.</param>
            <exception cref="T:System.OverflowException">The <paramref name="value"/> parameter represents a number less than <see cref="F:PcapDotNet.Base.UInt128.MinValue"/> or greater than <see cref="F:PcapDotNet.Base.UInt128.MaxValue"/>.</exception>
        </member>
        <member name="M:PcapDotNet.Base.UInt128.op_Explicit(System.Numerics.BigInteger)~PcapDotNet.Base.UInt128">
            <summary>
            Defines an explicit conversion of a <see cref="T:System.Numerics.BigInteger"/> object to an unsigned 128-bit integer value.
            </summary>
            <param name="value">The value to convert to an unsigned 128-bit integer.</param>
            <returns>The 128 bit value created by equivalent to <paramref name="value"/>.</returns>
            <exception cref="T:System.OverflowException">The <paramref name="value"/> parameter represents a number less than <see cref="F:PcapDotNet.Base.UInt128.MinValue"/> or greater than <see cref="F:PcapDotNet.Base.UInt128.MaxValue"/>.</exception>
        </member>
        <member name="M:PcapDotNet.Base.UInt128.op_Implicit(PcapDotNet.Base.UInt128)~System.Numerics.BigInteger">
            <summary>
            Converts the 128 bits unsigned integer to a <see cref="T:System.Numerics.BigInteger"/>.
            </summary>
            <param name="value">The 128 bit value to convert.</param>
            <returns>The <see cref="T:System.Numerics.BigInteger"/> value converted from the 128 bit value.</returns>
        </member>
        <member name="M:PcapDotNet.Base.UInt128.op_Implicit(System.UInt64)~PcapDotNet.Base.UInt128">
            <summary>
            Converts a 64 bit unsigned integer to a 128 bit unsigned integer by taking all the 64 bits.
            </summary>
            <param name="value">The 64 bit value to convert.</param>
            <returns>The 128 bit value created by taking all the 64 bits of the 64 bit value.</returns>
        </member>
        <member name="M:PcapDotNet.Base.UInt128.op_Explicit(PcapDotNet.Base.UInt128)~System.UInt64">
            <summary>
            Converts the 128 bits unsigned integer to a 64 bits unsigned integer.
            </summary>
            <param name="value">The 128 bit value to convert.</param>
            <returns>The 64 bit value converted from the 128 bit value.</returns>
        </member>
        <member name="M:PcapDotNet.Base.UInt128.Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider)">
            <summary>
            Converts the string representation of a number in a specified style and culture-specific format to its <see cref="T:PcapDotNet.Base.UInt128"/> equivalent.
            </summary>
            <param name="value">A string that contains a number to convert.</param>
            <param name="style">
            A bitwise combination of the enumeration values that specify the permitted format of value.
            </param>
            <param name="provider">An object that provides culture-specific formatting information about <paramref name="value"/>.</param>
            <returns>A value that is equivalent to the number specified in the value parameter.</returns>
            <exception cref="T:System.ArgumentException"><paramref name="style"/> is not a <see cref="T:System.Globalization.NumberStyles"/> value or <paramref name="style"/> includes the <see cref="F:System.Globalization.NumberStyles.AllowHexSpecifier"/> or <see cref="F:System.Globalization.NumberStyles.HexNumber"/> flag along with another value.</exception>
            <exception cref="T:System.ArgumentNullException"><paramref name="value"/> is null.</exception>
            <exception cref="T:System.FormatException"><paramref name="value"/> does not comply with the input pattern specified by <paramref name="style"/>.</exception>
            <exception cref="T:System.OverflowException">The <paramref name="value"/> parameter represents a number less than <see cref="F:PcapDotNet.Base.UInt128.MinValue"/> or greater than <see cref="F:PcapDotNet.Base.UInt128.MaxValue"/>.</exception>
            <remarks>
            The <paramref name="style"/> parameter defines the style elements 
            (such as white space, the positive or negative sign symbol, the group separator symbol, or the decimal point symbol) 
            that are allowed in the <paramref name="value"/> parameter for the parse operation to succeed. 
            <paramref name="style"/> must be a combination of bit flags from the <see cref="T:System.Globalization.NumberStyles"/> enumeration. 
            The <paramref name="style"/> parameter makes this method overload useful when <paramref name="value"/> contains the string representation of a hexadecimal value, 
            when the number system (decimal or hexadecimal) represented by value is known only at run time, or when you want to disallow white space or a sign symbol in value.
            <para>Depending on the value of <paramref name="style"/>, the <paramref name="value"/> parameter may include the following elements:</para>
            <para>[ws][$][sign][digits,]digits[.fractional_digits][E[sign]exponential_digits][ws]</para>
            <para>If <paramref name="style"/> includes <see cref="F:System.Globalization.NumberStyles.AllowHexSpecifier"/>, the <paramref name="value"/> parameter may include the following elements:</para>
            <para>[ws]hexdigits[ws]</para>
            <para>Elements in square brackets ([ and ]) are optional. The following table describes each element.</para>
              <list type="table">
                <listheader>
                  <term>Element</term>
                  <description>Description</description>
                </listheader>
                <item>
                  <term>ws</term>
                  <description>
                  Optional white space. 
                  White space can appear at the start of value if <paramref name="style"/> includes the <see cref="F:System.Globalization.NumberStyles.AllowLeadingWhite"/> flag, 
                  and it can appear at the end of value if <paramref name="style"/> includes the <see cref="F:System.Globalization.NumberStyles.AllowTrailingWhite"/> flag.
                  </description>
                </item>
                <item>
                  <term>$</term>
                  <description>
                  A culture-specific currency symbol. 
                  Its position in the string is defined by the <see cref="P:System.Globalization.NumberFormatInfo.CurrencyNegativePattern"/> and <see cref="P:System.Globalization.NumberFormatInfo.CurrencyPositivePattern"/> properties of the culture indicated by the <paramref name="provider"/> parameter. 
                  The current culture's currency symbol can appear in value if <paramref name="style"/> includes the <see cref="F:System.Globalization.NumberStyles.AllowCurrencySymbol"/> flag.
                  </description>
                </item>
                <item>
                  <term>sign</term>
                  <description>
                  An optional sign. 
                  The sign can appear at the start of <paramref name="value"/> if <paramref name="style"/> includes the <see cref="F:System.Globalization.NumberStyles.AllowLeadingSign"/> flag, 
                  and it can appear at the end of <paramref name="value"/> if <paramref name="style"/> includes the <see cref="F:System.Globalization.NumberStyles.AllowTrailingSign"/> flag. 
                  Parentheses can be used in <paramref name="value"/> to indicate a negative value if <paramref name="style"/> includes the <see cref="F:System.Globalization.NumberStyles.AllowParentheses"/> flag. 
                  </description>
                </item>
                <item>
                  <term>digits, fractional_digits, exponential_digits</term>
                  <description>A sequence of digits from 0 through 9. A sequence of digits from 0 through 9. For fractional_digits, only the digit 0 is valid.</description>
                </item>
                <item>
                  <term>,</term>
                  <description>
                  A culture-specific group separator symbol. 
                  The group separator symbol of the culture specified by <paramref name="provider"/> can appear in <paramref name="value"/> if <paramref name="style"/> includes the <see cref="F:System.Globalization.NumberStyles.AllowThousands"/> flag.
                  </description>
                </item>
                <item>
                  <term>.</term>
                  <description>
                  A culture-specific decimal point symbol. 
                  The decimal point symbol of the culture designated by <paramref name="provider"/> can appear in <paramref name="value"/> if <paramref name="style"/> includes the <see cref="F:System.Globalization.NumberStyles.AllowDecimalPoint"/> flag. 
                  Only the digit 0 can appear as a fractional digit for the parse operation to succeed; 
                  if fractional_digits includes any other digit, a <see cref="T:System.FormatException"/> is thrown.
                  </description>
                </item>
                <item>
                  <term>E</term>
                  <description>
                  The "e" or "E" character, which indicates that the value is represented in exponential (scientific) notation. 
                  The <paramref name="value"/> parameter can represent a number in exponential notation if <paramref name="style"/> includes the <see cref="F:System.Globalization.NumberStyles.AllowExponent"/> flag.
                  </description>
                </item>
                <item>
                  <term>hexdigits</term>
                  <description>A sequence of hexadecimal digits from 0 through f, or 0 through F.</description>
                </item>
              </list>
            If you use the <see cref="M:PcapDotNet.Base.UInt128.Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider)"/> method to round-trip the string representation of a <see cref="T:PcapDotNet.Base.UInt128"/> value that was output by the <see cref="M:PcapDotNet.Base.UInt128.ToString(System.String,System.IFormatProvider)"/> method, 
            you should use the <see cref="M:PcapDotNet.Base.UInt128.ToString(System.String,System.IFormatProvider)"/> method with the "R" format specifier to generate the string representation of the <see cref="T:PcapDotNet.Base.UInt128"/> value. 
            Otherwise, the string representation of the <see cref="T:PcapDotNet.Base.UInt128"/> preserves only the 50 most significant digits of the original value, and data may be lost when you use the <see cref="M:PcapDotNet.Base.UInt128.Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider)"/>  method to restore the <see cref="T:PcapDotNet.Base.UInt128"/> value.
            <note>
            Unlike the other <see cref="T:System.Globalization.NumberStyles"/> values, which allow for but do not require the presence of particular style elements in <paramref name="value"/>, 
            the <see cref="F:System.Globalization.NumberStyles.AllowHexSpecifier"/> style value means that the individual numeric characters in <paramref name="value"/> are always interpreted as hexadecimal characters. 
            Valid hexadecimal characters are 0-9, A-F, and a-f. 
            The only other flags that can be combined with the <paramref name="style"/> parameter are <see cref="F:System.Globalization.NumberStyles.AllowLeadingWhite"/> and <see cref="F:System.Globalization.NumberStyles.AllowTrailingWhite"/>. 
            (The <see cref="T:System.Globalization.NumberStyles"/> enumeration includes a composite number style, <see cref="F:System.Globalization.NumberStyles.HexNumber"/>, that includes both white-space flags.)
            </note>
            <note>
            If <paramref name="value"/> is the string representation of a hexadecimal number, it cannot be preceded by any decoration (such as 0x or &amp;h) that differentiates it as a hexadecimal number. 
            This causes the conversion to fail.
            </note>
            If <paramref name="value"/> is a hexadecimal string, the <see cref="M:PcapDotNet.Base.UInt128.Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider)"/> method interprets <paramref name="value"/> as a negative number stored by using two's complement representation if its first two hexadecimal digits are greater than or equal to 0x80. 
            In other words, the method interprets the highest-order bit of the first byte in <paramref name="value"/> as the sign bit. 
            To make sure that a hexadecimal string is correctly interpreted as a positive number, the first digit in <paramref name="value"/> must have a value of zero. 
            For example, the method interprets 0x80 as a negative value, but it interprets either 0x080 or 0x0080 as a positive value. 
            <para>
            The <paramref name="provider"/> parameter is an <see cref="T:System.IFormatProvider"/> implementation. 
            Its <see cref="M:System.IFormatProvider.GetFormat(System.Type)"/> method returns a <see cref="T:System.Globalization.NumberFormatInfo"/> object that provides culture-specific information about the format of value. 
            Typically, <paramref name="provider"/> can be any one of the following: 
            <list type="bullet">
              <item>
              A <see cref="T:System.Globalization.CultureInfo"/> object that represents the culture that provides numeric formatting information. 
              Its <see cref="M:System.Globalization.CultureInfo.GetFormat(System.Type)"/> method returns the <see cref="T:System.Globalization.NumberFormatInfo"/> object that provides numeric formatting information.
              </item>
              <item>A <see cref="T:System.Globalization.NumberFormatInfo"/> object that provides formatting information. (Its implementation of <see cref="M:System.Globalization.NumberFormatInfo.GetFormat(System.Type)"/> just returns itself.)</item>
              <item>
              A custom object that implements <see cref="T:System.IFormatProvider"/> and uses the <see cref="M:System.IFormatProvider.GetFormat(System.Type)"/> method 
              to instantiate and return the <see cref="T:System.Globalization.NumberFormatInfo"/> object that provides formatting information.
              </item>
            </list>
            If <paramref name="provider"/> is <see langword="null"/>, the <see cref="T:System.Globalization.NumberFormatInfo"/> object for the current culture is used.
            </para>
            </remarks>
        </member>
        <member name="M:PcapDotNet.Base.UInt128.Parse(System.String,System.IFormatProvider)">
            <summary>
            Converts the string representation of a number in a specified culture-specific format to its <see cref="T:PcapDotNet.Base.UInt128"/> equivalent.
            Uses <see cref="F:System.Globalization.NumberStyles.Integer"/> style.
            </summary>
            <param name="value">A string that contains a number to convert.</param>
            <param name="provider">An object that provides culture-specific formatting information about <paramref name="value"/>.</param>
            <returns>A value that is equivalent to the number specified in the value parameter.</returns>
            <exception cref="T:System.ArgumentNullException"><paramref name="value"/> is null.</exception>
            <exception cref="T:System.OverflowException">The <paramref name="value"/> parameter represents a number less than <see cref="F:PcapDotNet.Base.UInt128.MinValue"/> or greater than <see cref="F:PcapDotNet.Base.UInt128.MaxValue"/>.</exception>
            <remarks>
            See important remarks in <see cref="M:PcapDotNet.Base.UInt128.Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider)"/>
            </remarks>
        </member>
        <member name="M:PcapDotNet.Base.UInt128.Parse(System.String,System.Globalization.NumberStyles)">
            <summary>
            Converts the string representation of a number in a specified style to its <see cref="T:PcapDotNet.Base.UInt128"/> equivalent.
            Uses <see cref="P:System.Globalization.CultureInfo.CurrentCulture"/> as the format provider.
            </summary>
            <param name="value">A string that contains a number to convert.</param>
            <param name="style"> A bitwise combination of the enumeration values that specify the permitted format of value.</param>
            <returns>A value that is equivalent to the number specified in the value parameter.</returns>
            <exception cref="T:System.ArgumentException"><paramref name="style"/> is not a <see cref="T:System.Globalization.NumberStyles"/> value or <paramref name="style"/> includes the <see cref="F:System.Globalization.NumberStyles.AllowHexSpecifier"/> or <see cref="F:System.Globalization.NumberStyles.HexNumber"/> flag along with another value.</exception>
            <exception cref="T:System.ArgumentNullException"><paramref name="value"/> is null.</exception>
            <exception cref="T:System.FormatException"><paramref name="value"/> does not comply with the input pattern specified by <paramref name="style"/>.</exception>
            <exception cref="T:System.OverflowException">The <paramref name="value"/> parameter represents a number less than <see cref="F:PcapDotNet.Base.UInt128.MinValue"/> or greater than <see cref="F:PcapDotNet.Base.UInt128.MaxValue"/>.</exception>
            <remarks>
            See important remarks in <see cref="M:PcapDotNet.Base.UInt128.Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider)"/>
            </remarks>
        </member>
        <member name="M:PcapDotNet.Base.UInt128.Parse(System.String)">
            <summary>
            Converts the string representation of a number in a specified style to its <see cref="T:PcapDotNet.Base.UInt128"/> equivalent.
            Uses <see cref="F:System.Globalization.NumberStyles.Integer"/> style.
            Uses <see cref="P:System.Globalization.CultureInfo.CurrentCulture"/> as the format provider.
            </summary>
            <param name="value">A string that contains a number to convert.</param>
            <returns>A value that is equivalent to the number specified in the value parameter.</returns>
            <exception cref="T:System.ArgumentNullException"><paramref name="value"/> is null.</exception>
            <exception cref="T:System.OverflowException">The <paramref name="value"/> parameter represents a number less than <see cref="F:PcapDotNet.Base.UInt128.MinValue"/> or greater than <see cref="F:PcapDotNet.Base.UInt128.MaxValue"/>.</exception>
            <remarks>
            See important remarks in <see cref="M:PcapDotNet.Base.UInt128.Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider)"/>
            </remarks>
        </member>
        <member name="M:PcapDotNet.Base.UInt128.TryParse(System.String,System.Globalization.NumberStyles,System.IFormatProvider,PcapDotNet.Base.UInt128@)">
            <summary>
            Tries to convert the string representation of a number in a specified style and culture-specific format to its <see cref="T:PcapDotNet.Base.UInt128"/> equivalent, 
            and returns a value that indicates whether the conversion succeeded.
            </summary>
            <param name="value">The string representation of a number. The string is interpreted using the style specified by <paramref name="style"/>.</param>
            <param name="style">
            A bitwise combination of enumeration values that indicates the style elements that can be present in <paramref name="value"/>. 
            A typical value to specify is <see cref="F:System.Globalization.NumberStyles.Integer"/>.
            </param>
            <param name="provider">An object that supplies culture-specific formatting information about <paramref name="value"/>.</param>
            <param name="result">
            When this method returns, contains the <see cref="T:PcapDotNet.Base.UInt128"/> equivalent to the number that is contained in value, or <see cref="F:PcapDotNet.Base.UInt128.Zero"/> if the conversion failed. 
            The conversion fails if the value parameter is <see langword="null"/>, is not in a format that is compliant with <paramref name="style"/> or represents a number that is less than <see cref="F:PcapDotNet.Base.UInt128.MinValue"/> or greater than <see cref="F:PcapDotNet.Base.UInt128.MaxValue"/>. 
            This parameter is passed uninitialized.</param>
            <returns>true if the <paramref name="value"/> parameter was converted successfully; otherwise, false.</returns>
            <remarks>
            The <see cref="M:PcapDotNet.Base.UInt128.TryParse(System.String,System.Globalization.NumberStyles,System.IFormatProvider,PcapDotNet.Base.UInt128@)"/> method is like the <see cref="M:PcapDotNet.Base.UInt128.Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider)"/> method, 
            except that it does not throw an exception if the conversion fails. 
            This method eliminates the need to use exception handling to test for a <see cref="T:System.FormatException"/> if <paramref name="value"/> is invalid and cannot be parsed successfully.
            <para>For more information see <see cref="M:PcapDotNet.Base.UInt128.Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider)"/></para>
            </remarks>
        </member>
        <member name="M:PcapDotNet.Base.UInt128.TryParse(System.String,PcapDotNet.Base.UInt128@)">
            <summary>
            Tries to convert the string representation of a number to its <see cref="T:PcapDotNet.Base.UInt128"/> equivalent, 
            and returns a value that indicates whether the conversion succeeded.
            </summary>
            <param name="value">The string representation of a number.</param>
            <param name="result">
            When this method returns, contains the <see cref="T:PcapDotNet.Base.UInt128"/> equivalent to the number that is contained in value, or <see cref="F:PcapDotNet.Base.UInt128.Zero"/> if the conversion failed. 
            The conversion fails if the value parameter is <see langword="null"/> or represents a number that is less than <see cref="F:PcapDotNet.Base.UInt128.MinValue"/> or greater than <see cref="F:PcapDotNet.Base.UInt128.MaxValue"/>. 
            This parameter is passed uninitialized.</param>
            <returns>true if the <paramref name="value"/> parameter was converted successfully; otherwise, false.</returns>
            <remarks>
            The <see cref="M:PcapDotNet.Base.UInt128.TryParse(System.String,PcapDotNet.Base.UInt128@)"/> method is like the <see cref="M:PcapDotNet.Base.UInt128.Parse(System.String)"/> method, 
            except that it does not throw an exception if the conversion fails. 
            This method eliminates the need to use exception handling to test for a <see cref="T:System.FormatException"/> if <paramref name="value"/> is invalid and cannot be parsed successfully.
            <para>For more information see <see cref="M:PcapDotNet.Base.UInt128.Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider)"/></para>
            </remarks>
        </member>
        <member name="M:PcapDotNet.Base.UInt128.Equals(PcapDotNet.Base.UInt128)">
            <summary>
            Returns true iff the two values represent the same value.
            </summary>
            <param name="other">The value to compare to.</param>
            <returns>True iff the two values represent the same value.</returns>
        </member>
        <member name="M:PcapDotNet.Base.UInt128.Equals(System.Object)">
            <summary>
            Indicates whether this instance and a specified object are equal.
            </summary>
            <returns>
            true if <paramref name="obj"/> and this instance are the same type and represent the same value; otherwise, false.
            </returns>
            <param name="obj">Another object to compare to. </param><filterpriority>2</filterpriority>
        </member>
        <member name="M:PcapDotNet.Base.UInt128.CompareTo(PcapDotNet.Base.UInt128)">
            <summary>
            Compares the current object with another object of the same type.
            </summary>
            <returns>
            A value that indicates the relative order of the objects being compared.
            The return value has the following meanings:
            Less than zero - This object is less than the <paramref name="other"/>.
            parameter.Zero - This object is equal to <paramref name="other"/>.
            Greater than zero - This object is greater than <paramref name="other"/>. 
            </returns>
            <param name="other">An object to compare with this object.</param>
        </member>
        <member name="M:PcapDotNet.Base.UInt128.op_Equality(PcapDotNet.Base.UInt128,PcapDotNet.Base.UInt128)">
            <summary>
            Returns true iff the two values represent the same value.
            </summary>
            <param name="value1">The first value to compare.</param>
            <param name="value2">The second value to compare.</param>
            <returns>True iff the two values represent the same value.</returns>
        </member>
        <member name="M:PcapDotNet.Base.UInt128.op_Inequality(PcapDotNet.Base.UInt128,PcapDotNet.Base.UInt128)">
            <summary>
            Returns true iff the two values represent different values.
            </summary>
            <param name="value1">The first value to compare.</param>
            <param name="value2">The second value to compare.</param>
            <returns>True iff the two values represent different values.</returns>
        </member>
        <member name="M:PcapDotNet.Base.UInt128.op_LessThan(PcapDotNet.Base.UInt128,PcapDotNet.Base.UInt128)">
            <summary>
            Returns true iff the first value is smaller than the second value.
            </summary>
            <param name="value1">The first value to compare.</param>
            <param name="value2">The second value to compare.</param>
            <returns>True iff the first value is smaller than the second value.</returns>
        </member>
        <member name="M:PcapDotNet.Base.UInt128.op_GreaterThan(PcapDotNet.Base.UInt128,PcapDotNet.Base.UInt128)">
            <summary>
            Returns true iff the first value is greater than the second value.
            </summary>
            <param name="value1">The first value to compare.</param>
            <param name="value2">The second value to compare.</param>
            <returns>True iff the first value is greater than the second value.</returns>
        </member>
        <member name="M:PcapDotNet.Base.UInt128.op_LessThanOrEqual(PcapDotNet.Base.UInt128,PcapDotNet.Base.UInt128)">
            <summary>
            Returns true iff the first value is smaller than or equal to the second value.
            </summary>
            <param name="value1">The first value to compare.</param>
            <param name="value2">The second value to compare.</param>
            <returns>True iff the first value is smaller than  or equal to the second value.</returns>
        </member>
        <member name="M:PcapDotNet.Base.UInt128.op_GreaterThanOrEqual(PcapDotNet.Base.UInt128,PcapDotNet.Base.UInt128)">
            <summary>
            Returns true iff the first value is greater than or equal to the second value.
            </summary>
            <param name="value1">The first value to compare.</param>
            <param name="value2">The second value to compare.</param>
            <returns>True iff the first value is greater than  or equal to the second value.</returns>
        </member>
        <member name="M:PcapDotNet.Base.UInt128.op_RightShift(PcapDotNet.Base.UInt128,System.Int32)">
            <summary>
            Shifts its first operand right by the number of bits specified by its second operand.
            </summary>
            <param name="value">The value to shift.</param>
            <param name="numberOfBits">The number of bits to shift.</param>
            <returns>The value after it was shifted by the given number of bits.</returns>
        </member>
        <member name="M:PcapDotNet.Base.UInt128.op_LeftShift(PcapDotNet.Base.UInt128,System.Int32)">
            <summary>
            Shifts its first operand left by the number of bits specified by its second operand.
            </summary>
            <param name="value">The value to shift.</param>
            <param name="numberOfBits">The number of bits to shift.</param>
            <returns>The value after it was shifted by the given number of bits.</returns>
        </member>
        <member name="M:PcapDotNet.Base.UInt128.RightShift(PcapDotNet.Base.UInt128,System.Int32)">
            <summary>
            Shifts its first operand right by the number of bits specified by its second operand.
            </summary>
            <param name="value">The value to shift.</param>
            <param name="numberOfBits">The number of bits to shift.</param>
            <returns>The value after it was shifted by the given number of bits.</returns>
        </member>
        <member name="M:PcapDotNet.Base.UInt128.LeftShift(PcapDotNet.Base.UInt128,System.Int32)">
            <summary>
            Shifts its first operand left by the number of bits specified by its second operand.
            </summary>
            <param name="value">The value to shift.</param>
            <param name="numberOfBits">The number of bits to shift.</param>
            <returns>The value after it was shifted by the given number of bits.</returns>
        </member>
        <member name="M:PcapDotNet.Base.UInt128.op_BitwiseAnd(PcapDotNet.Base.UInt128,PcapDotNet.Base.UInt128)">
            <summary>
            Bitwise ands between two values.
            </summary>
            <param name="value1">The first value to do bitwise and.</param>
            <param name="value2">The second value to do bitwise and.</param>
            <returns>The two values after they were bitwise anded.</returns>
        </member>
        <member name="M:PcapDotNet.Base.UInt128.BitwiseAnd(PcapDotNet.Base.UInt128,PcapDotNet.Base.UInt128)">
            <summary>
            Bitwise ands between two values.
            </summary>
            <param name="value1">The first value to do bitwise and.</param>
            <param name="value2">The second value to do bitwise and.</param>
            <returns>The two values after they were bitwise anded.</returns>
        </member>
        <member name="M:PcapDotNet.Base.UInt128.op_BitwiseOr(PcapDotNet.Base.UInt128,PcapDotNet.Base.UInt128)">
            <summary>
            Bitwise ors between two values.
            </summary>
            <param name="value1">The first value to do bitwise or.</param>
            <param name="value2">The second value to do bitwise or.</param>
            <returns>The two values after they were bitwise ored.</returns>
        </member>
        <member name="M:PcapDotNet.Base.UInt128.BitwiseOr(PcapDotNet.Base.UInt128,PcapDotNet.Base.UInt128)">
            <summary>
            Bitwise ors between two values.
            </summary>
            <param name="value1">The first value to do bitwise or.</param>
            <param name="value2">The second value to do bitwise or.</param>
            <returns>The two values after they were bitwise ored.</returns>
        </member>
        <member name="M:PcapDotNet.Base.UInt128.op_Addition(PcapDotNet.Base.UInt128,PcapDotNet.Base.UInt128)">
            <summary>
            Sums the given values and returns the sum.
            </summary>
            <param name="value1">The first value to sum.</param>
            <param name="value2">The second value to sum.</param>
            <returns>The sum of the given values.</returns>
        </member>
        <member name="M:PcapDotNet.Base.UInt128.Add(PcapDotNet.Base.UInt128,PcapDotNet.Base.UInt128)">
            <summary>
            Sums the given values and returns the sum.
            </summary>
            <param name="value1">The first value to sum.</param>
            <param name="value2">The second value to sum.</param>
            <returns>The sum of the given values.</returns>
        </member>
        <member name="M:PcapDotNet.Base.UInt128.op_Subtraction(PcapDotNet.Base.UInt128,PcapDotNet.Base.UInt128)">
            <summary>
            Substract the second value from the first value and returns the result of the substraction.
            </summary>
            <param name="value1">The first value to sum.</param>
            <param name="value2">The second value to sum.</param>
            <returns>The result of substracting the second value from the first value.</returns>
        </member>
        <member name="M:PcapDotNet.Base.UInt128.Subtract(PcapDotNet.Base.UInt128,PcapDotNet.Base.UInt128)">
            <summary>
            Substract the second value from the first value and returns the result of the substraction.
            </summary>
            <param name="value1">The first value to sum.</param>
            <param name="value2">The second value to sum.</param>
            <returns>The result of substracting the second value from the first value.</returns>
        </member>
        <member name="M:PcapDotNet.Base.UInt128.GetHashCode">
            <summary>
            Returns the hash code for this instance.
            </summary>
            <returns>
            A 32-bit signed integer that is the hash code for this instance.
            </returns>
            <filterpriority>2</filterpriority>
        </member>
        <member name="M:PcapDotNet.Base.UInt128.ToString(System.String,System.IFormatProvider)">
            <summary>
            Converts the numeric value of the current <see cref="T:PcapDotNet.Base.UInt128"/> object to its equivalent string representation by using the specified format and culture-specific format information.
            </summary>
            <param name="format">A standard or custom numeric format string.</param>
            <param name="formatProvider">An object that supplies culture-specific formatting information.</param>
            <returns>The string representation of the current <see cref="T:PcapDotNet.Base.UInt128"/> value as specified by the <paramref name="format"/> and <paramref name="formatProvider"/> parameters.</returns>
            <exception cref="T:System.FormatException"><paramref name="format"/> is not a valid format string.</exception>
            <remarks>
            The <paramref name="format"/> parameter can be any valid standard numeric format specifier, or any combination of custom numeric format specifiers. 
            If <paramref name="format"/> is equal to <see cref="F:System.String.Empty"/> or is <see langword="null"/>, the return value of the current <see cref="T:PcapDotNet.Base.UInt128"/> object is formatted with the general format specifier ("G"). 
            If <paramref name="format"/> is any other value, the method throws a <see cref="T:System.FormatException"/>.
            <para>
            The <paramref name="formatProvider"/> parameter is an <see cref="T:System.IFormatProvider"/> implementation. 
            Its <see cref="M:System.IFormatProvider.GetFormat(System.Type)"/> method returns a <see cref="T:System.Globalization.NumberFormatInfo"/> object that provides culture-specific information about the format of the string returned by this method. 
            When the <see cref="M:PcapDotNet.Base.UInt128.ToString(System.String,System.IFormatProvider)"/> method is invoked, it calls the <paramref name="formatProvider"/> parameter's <see cref="M:System.IFormatProvider.GetFormat(System.Type)"/> method and passes it a <see cref="T:System.Type"/> object that represents the <see cref="T:System.Globalization.NumberFormatInfo"/> type. 
            The <see cref="M:System.IFormatProvider.GetFormat(System.Type)"/> method then returns the <see cref="T:System.Globalization.NumberFormatInfo"/> object that provides information for formatting the <see cref="T:PcapDotNet.Base.UInt128"/> object, such as the negative sign symbol, the group separator symbol, or the decimal point symbol. 
            There are three ways to use the <paramref name="formatProvider"/> parameter to supply formatting information to the <see cref="M:PcapDotNet.Base.UInt128.ToString(System.String,System.IFormatProvider)"/> method: 
            <list type="bullet">
              <item>
              You can pass a <see cref="T:System.Globalization.CultureInfo"/> object that represents the culture that provides numeric formatting information. 
              Its <see cref="M:System.Globalization.CultureInfo.GetFormat(System.Type)"/> method returns the <see cref="T:System.Globalization.NumberFormatInfo"/> object that provides numeric formatting information.
              </item>
              <item>You can pass the actual <see cref="T:System.Globalization.NumberFormatInfo"/> object that provides formatting information. (Its implementation of <see cref="M:System.Globalization.NumberFormatInfo.GetFormat(System.Type)"/> just returns itself.)</item>
              <item>
              You can pas a custom object that implements <see cref="T:System.IFormatProvider"/> and uses the <see cref="M:System.IFormatProvider.GetFormat(System.Type)"/> method 
              to instantiate and return the <see cref="T:System.Globalization.NumberFormatInfo"/> object that provides formatting information.
              </item>
            </list>
            If <paramref name="formatProvider"/> is <see langword="null"/>, the formatting of the returned string is based on the <see cref="T:System.Globalization.NumberFormatInfo"/> object of the current culture.
            </para>
            </remarks>
        </member>
        <member name="M:PcapDotNet.Base.UInt128.ToString(System.String)">
            <summary>
            Converts the numeric value of the current <see cref="T:PcapDotNet.Base.UInt128"/> object to its equivalent string representation by using the specified format.
            Uses <see cref="P:System.Globalization.CultureInfo.CurrentCulture"/> as the format provider.
            </summary>
            <param name="format">A standard or custom numeric format string.</param>
            <returns>The string representation of the current <see cref="T:PcapDotNet.Base.UInt128"/> value as specified by the <paramref name="format"/> parameter.</returns>
            <exception cref="T:System.FormatException"><paramref name="format"/> is not a valid format string.</exception>
            <remarks>
            See <see cref="M:PcapDotNet.Base.UInt128.ToString(System.String,System.IFormatProvider)"/> for remarks.
            </remarks>
        </member>
        <member name="M:PcapDotNet.Base.UInt128.ToString(System.IFormatProvider)">
            <summary>
            Converts the numeric value of the current <see cref="T:PcapDotNet.Base.UInt128"/> object to its equivalent string representation by using the specified culture-specific format information.
            Uses "G" format.
            </summary>
            <param name="provider">An object that supplies culture-specific formatting information.</param>
            <returns>The string representation of the current <see cref="T:PcapDotNet.Base.UInt128"/> value as specified by the <paramref name="provider"/> parameter.</returns>
            <remarks>
            See <see cref="M:PcapDotNet.Base.UInt128.ToString(System.String,System.IFormatProvider)"/> for remarks.
            </remarks>
        </member>
        <member name="M:PcapDotNet.Base.UInt128.ToString">
            <summary>
            Converts the numeric value of the current <see cref="T:PcapDotNet.Base.UInt128"/> object to its equivalent string representation.
            Uses "G" format.
            Uses <see cref="P:System.Globalization.CultureInfo.CurrentCulture"/> as the format provider.
            </summary>
            <returns>The string representation of the current <see cref="T:PcapDotNet.Base.UInt128"/> value.</returns>
            <remarks>
            See <see cref="M:PcapDotNet.Base.UInt128.ToString(System.String,System.IFormatProvider)"/> for remarks.
            </remarks>
        </member>
        <member name="T:PcapDotNet.Base.UInt24">
            <summary>
            A 24 bit unsigned integer.
            </summary>
        </member>
        <member name="F:PcapDotNet.Base.UInt24.SizeOf">
            <summary>
            The number of bytes this type will take.
            </summary>
        </member>
        <member name="F:PcapDotNet.Base.UInt24.MaxValue">
            <summary>
            The maximum value of this type.
            </summary>
        </member>
        <member name="M:PcapDotNet.Base.UInt24.op_Implicit(System.UInt16)~PcapDotNet.Base.UInt24">
            <summary>
            Converts a 16 bit unsigned integer to a 24 bit unsigned integer.
            </summary>
            <param name="value">The 16 bit value to convert.</param>
            <returns>The 24 bit value created.</returns>
        </member>
        <member name="M:PcapDotNet.Base.UInt24.op_Explicit(System.Int32)~PcapDotNet.Base.UInt24">
            <summary>
            Converts a 32 bit signed integer to a 24 bit unsigned integer by taking the 24 least significant bits.
            </summary>
            <param name="value">The 32 bit value to convert.</param>
            <returns>The 24 bit value created by taking the 24 least significant bits of the 32 bit value.</returns>
        </member>
        <member name="M:PcapDotNet.Base.UInt24.op_Explicit(System.UInt32)~PcapDotNet.Base.UInt24">
            <summary>
            Converts a 32 bit unsigned integer to a 24 bit unsigned integer by taking the 24 least significant bits.
            </summary>
            <param name="value">The 32 bit value to convert.</param>
            <returns>The 24 bit value created by taking the 24 least significant bits of the 32 bit value.</returns>
        </member>
        <member name="M:PcapDotNet.Base.UInt24.op_Implicit(PcapDotNet.Base.UInt24)~System.Int32">
            <summary>
            Converts the 24 bits unsigned integer to a 32 bits signed integer.
            </summary>
            <param name="value">The 24 bit value to convert.</param>
            <returns>The 32 bit value converted from the 24 bit value.</returns>
        </member>
        <member name="M:PcapDotNet.Base.UInt24.Equals(PcapDotNet.Base.UInt24)">
            <summary>
            Returns true iff the two values represent the same value.
            </summary>
            <param name="other">The value to compare to.</param>
            <returns>True iff the two values represent the same value.</returns>
        </member>
        <member name="M:PcapDotNet.Base.UInt24.Equals(System.Object)">
            <summary>
            Indicates whether this instance and a specified object are equal.
            </summary>
            <returns>
            true if <paramref name="obj"/> and this instance are the same type and represent the same value; otherwise, false.
            </returns>
            <param name="obj">Another object to compare to. </param><filterpriority>2</filterpriority>
        </member>
        <member name="M:PcapDotNet.Base.UInt24.op_Equality(PcapDotNet.Base.UInt24,PcapDotNet.Base.UInt24)">
            <summary>
            Returns true iff the two values represent the same value.
            </summary>
            <param name="value1">The first value to compare.</param>
            <param name="value2">The second value to compare.</param>
            <returns>True iff the two values represent the same value.</returns>
        </member>
        <member name="M:PcapDotNet.Base.UInt24.op_Inequality(PcapDotNet.Base.UInt24,PcapDotNet.Base.UInt24)">
            <summary>
            Returns true iff the two values represent different values.
            </summary>
            <param name="value1">The first value to compare.</param>
            <param name="value2">The second value to compare.</param>
            <returns>True iff the two values represent different values.</returns>
        </member>
        <member name="M:PcapDotNet.Base.UInt24.GetHashCode">
            <summary>
            Returns the hash code for this instance.
            </summary>
            <returns>
            A 32-bit signed integer that is the hash code for this instance.
            </returns>
            <filterpriority>2</filterpriority>
        </member>
        <member name="M:PcapDotNet.Base.UInt24.ToString">
            <summary>
            Returns the fully qualified type name of this instance.
            </summary>
            <returns>
            A <see cref="T:System.String"/> containing a fully qualified type name.
            </returns>
            <filterpriority>2</filterpriority>
        </member>
        <member name="T:PcapDotNet.Base.UInt48">
            <summary>
            A 48 bit unsigned integer.
            </summary>
        </member>
        <member name="F:PcapDotNet.Base.UInt48.SizeOf">
            <summary>
            The number of bytes this type will take.
            </summary>
        </member>
        <member name="F:PcapDotNet.Base.UInt48.MinValue">
            <summary>
            The minimum value of this type.
            </summary>
        </member>
        <member name="F:PcapDotNet.Base.UInt48.MaxValue">
            <summary>
            The maximum value of this type.
            </summary>
        </member>
        <member name="M:PcapDotNet.Base.UInt48.Parse(System.String)">
            <summary>
            Converts the string representation of a number to its 48-bit unsigned integer equivalent.
            </summary>
            <param name="value">A string that represents the number to convert.</param>
            <returns>A 48-bit unsigned integer equivalent to the number contained in <paramref name="value"/>.</returns>
            <exception cref="T:System.ArgumentNullException">The <paramref name="value"/> parameter is <see langword="null"/>.</exception>
            <exception cref="T:System.FormatException">The <paramref name="value"/> parameter is not in the correct format.</exception>
            <exception cref="T:System.OverflowException">The <paramref name="value"/> parameter represents a number less than <see cref="F:PcapDotNet.Base.UInt48.MinValue"/> or greater than <see cref="F:PcapDotNet.Base.UInt48.MaxValue"/>.</exception>
            <remarks>
            The <paramref name="value"/> parameter should be the string representation of a number in the following form.
            <para>[ws][sign]digits[ws]</para>
            <para> Elements in square brackets ([ and ]) are optional. The following table describes each element.</para>
              <list type="table">
                <listheader>
                  <term>Element</term>
                  <description>Description</description>
                </listheader>
                <item><term>ws</term><description>Optional white space.</description></item>
                <item>
                  <term>sign</term>
                  <description>
                  An optional sign. 
                  Valid sign characters are determined by the <see cref="P:System.Globalization.NumberFormatInfo.NegativeSign"/> and <see cref="P:System.Globalization.NumberFormatInfo.PositiveSign"/> properties of the current culture. 
                  However, the negative sign symbol can be used only with zero; otherwise, the method throws an <see cref="T:System.OverflowException"/>.
                  </description>
                </item>
                <item><term>digits</term><description>A sequence of digits from 0 through 9. Any leading zeros are ignored.</description></item>
              </list>
              <note>
              The <paramref name="value"/> parameter is interpreted using the <see cref="F:System.Globalization.NumberStyles.Integer"/> style. 
              It cannot contain any group separators or decimal separator, and it cannot have a decimal portion.
              </note>
              The <paramref name="value"/> parameter is parsed by using the formatting information in a <see cref="T:System.Globalization.NumberFormatInfo"/> object that is initialized for the current system culture. 
              For more information, see <see cref="P:System.Globalization.NumberFormatInfo.CurrentInfo"/>. 
              To parse a string by using the formatting information of a specific culture, use the <see cref="M:PcapDotNet.Base.UInt48.Parse(System.String,System.IFormatProvider)"/> method.
            </remarks>
        </member>
        <member name="M:PcapDotNet.Base.UInt48.Parse(System.String,System.IFormatProvider)">
            <summary>
            Converts the string representation of a number in a specified culture-specific format to its 48-bit unsigned integer equivalent.
            </summary>
            <param name="value">A string that represents the number to convert.</param>
            <param name="provider">An object that supplies culture-specific formatting information about <paramref name="value"/>.</param>
            <returns>A 48-bit unsigned integer equivalent to the number specified in <paramref name="value"/>.</returns>
            <exception cref="T:System.ArgumentNullException">The <paramref name="value"/> parameter is <see langword="null"/>.</exception>
            <exception cref="T:System.FormatException">The <paramref name="value"/> parameter is not in the correct style.</exception>
            <exception cref="T:System.OverflowException">
              The <paramref name="value"/> parameter represents a number less than <see cref="F:PcapDotNet.Base.UInt48.MinValue"/> or greater than <see cref="F:PcapDotNet.Base.UInt48.MaxValue"/>. 
            </exception>
            <remarks>
            This overload of the Parse(String, IFormatProvider) method is typically used to convert text that can be formatted in a variety of ways to a <see cref="T:PcapDotNet.Base.UInt48"/> value. 
            For example, it can be used to convert the text entered by a user into an HTML text box to a numeric value.
            <para>The <paramref name="value"/> parameter contains a number of the form:</para>
            <para>[ws][sign]digits[ws]</para>
            <para>
              Elements in square brackets ([ and ]) are optional. 
              The following table describes each element:        
            </para>
              <list type="table">
                <listheader>
                  <term>Element</term>
                  <description>Description</description>
                </listheader>
                <item><term>ws</term><description>Optional white space.</description></item>
                <item>
                  <term>sign</term>
                  <description>An optional positive sign, or a negative sign if <paramref name="value"/> represents the value zero.</description>
                </item>
                <item><term>digits</term><description>A sequence of digits from 0 through 9.</description></item>
              </list>
              The <paramref name="value"/> parameter is interpreted using the <see cref="F:System.Globalization.NumberStyles.Integer"/> style. 
              In addition to the unsigned integer value's decimal digits, only leading and trailing spaces along with a leading sign is allowed. 
              (If the negative sign is present, <paramref name="value"/> must represent a value of zero, or the method throws an <see cref="T:System.OverflowException"/>.) 
              To explicitly define the style elements together with the culture-specific formatting information that can be present in <paramref name="value"/>, use the <see cref="M:PcapDotNet.Base.UInt48.Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider)"/> method.
              <para>
              The <paramref name="provider"/> parameter is an <see cref="T:System.IFormatProvider"/> implementation whose <see cref="M:System.IFormatProvider.GetFormat(System.Type)"/> method returns a <see cref="T:System.Globalization.NumberFormatInfo"/> object that provides culture-specific information about the format of <paramref name="value"/>. 
              There are three ways to use the <paramref name="provider"/> parameter to supply custom formatting information to the parse operation:
              </para>
              <list type="bullet">
                <item>You can pass the actual <see cref="T:System.Globalization.NumberFormatInfo"/> object that provides formatting information. (Its implementation of <see cref="M:System.IFormatProvider.GetFormat(System.Type)"/> simply returns itself.)</item>
                <item>You can pass a <see cref="T:System.Globalization.CultureInfo"/> object that specifies the culture whose formatting is to be used. Its <see cref="P:System.Globalization.CultureInfo.NumberFormat"/> property provides formatting information.</item>
                <item>You can pass a custom <see cref="T:System.IFormatProvider"/> implementation. Its <see cref="M:System.IFormatProvider.GetFormat(System.Type)"/> method must instantiate and return the <see cref="T:System.Globalization.NumberFormatInfo"/> object that provides formatting information.</item>
              </list>
              If provider is <see langword="null"/>, the <see cref="T:System.Globalization.NumberFormatInfo"/> object for the current culture is used.
            </remarks>
        </member>
        <member name="M:PcapDotNet.Base.UInt48.Parse(System.String,System.Globalization.NumberStyles)">
            <summary>
            Converts the string representation of a number in a specified style to its 48-bit unsigned integer equivalent.
            </summary>
            <param name="value">
            A string that represents the number to convert. 
            The string is interpreted by using the style specified by the <paramref name="style"/> parameter.
            </param>
            <param name="style">
            A bitwise combination of the enumeration values that specifies the permitted format of <paramref name="value"/>. 
            A typical value to specify is <see cref="F:System.Globalization.NumberStyles.Integer"/>.
            </param>
            <returns>A 48-bit unsigned integer equivalent to the number specified in <paramref name="value"/>.</returns>
            <exception cref="T:System.ArgumentNullException">The <paramref name="value"/> parameter is <see langword="null"/>.</exception>
            <exception cref="T:System.ArgumentException">
              <paramref name="style"/> is not a <see cref="T:System.Globalization.NumberStyles"/> value.
              <para>-or-</para>
              <para><paramref name="style"/> is not a combination of <see cref="F:System.Globalization.NumberStyles.AllowHexSpecifier"/> and <see cref="F:System.Globalization.NumberStyles.HexNumber"/> values.</para>
            </exception>
            <exception cref="T:System.FormatException">The <paramref name="value"/> parameter is not in a format compliant with <paramref name="style"/>.</exception>
            <exception cref="T:System.OverflowException">
              The <paramref name="value"/> parameter represents a number less than <see cref="F:PcapDotNet.Base.UInt48.MinValue"/> or greater than <see cref="F:PcapDotNet.Base.UInt48.MaxValue"/>. 
              <para>-or-</para>
              <para><paramref name="value"/> includes non-zero, fractional digits.</para>
            </exception>
            <remarks>
            The <paramref name="style"/> parameter defines the style elements (such as white space, the positive or negative sign symbol, the group separator symbol, or the decimal point symbol) that are allowed in the s parameter for the parse operation to succeed. 
            It must be a combination of bit flags from the <see cref="T:System.Globalization.NumberStyles"/> enumeration.
            <para>Depending on the value of style, the <paramref name="value"/> parameter may include the following elements:</para>
            <para>[ws][$][sign][digits,]digits[.fractional_digits][E[sign]exponential_digits][ws]</para>
            <para>
              Elements in square brackets ([ and ]) are optional. 
              If <paramref name="style"/> includes <see cref="F:System.Globalization.NumberStyles.AllowHexSpecifier"/>, the <paramref name="value"/> parameter may contain the following elements:
            </para>
            <para>[ws]hexdigits[ws]</para>
            <para>The following table describes each element.</para>
              <list type="table">
                <listheader>
                  <term>Element</term>
                  <description>Description</description>
                </listheader>
                <item>
                  <term>ws</term>
                  <description>
                  Optional white space. 
                  White space can appear at the start of <paramref name="value"/> if <paramref name="style"/> includes the <see cref="F:System.Globalization.NumberStyles.AllowLeadingWhite"/> flag, 
                  and it can appear at the end of <paramref name="style"/> if <paramref name="style"/> includes the <see cref="F:System.Globalization.NumberStyles.AllowTrailingWhite"/> flag.
                  </description>
                </item>
                <item>
                  <term>$</term>
                  <description>
                  A culture-specific currency symbol. 
                  Its position in the string is defined by the <see cref="P:System.Globalization.NumberFormatInfo.CurrencyNegativePattern"/> and <see cref="P:System.Globalization.NumberFormatInfo.CurrencyPositivePattern"/> properties of the current culture. 
                  The current culture's currency symbol can appear in <paramref name="value"/> if <paramref name="style"/> includes the <see cref="F:System.Globalization.NumberStyles.AllowCurrencySymbol"/> flag.
                  </description>
                </item>
                <item>
                  <term>sign</term>
                  <description>
                  An optional sign. 
                  The sign can appear at the start of <paramref name="value"/> if <paramref name="style"/> includes the <see cref="F:System.Globalization.NumberStyles.AllowLeadingSign"/> flag, and it can appear at the end of <paramref name="value"/> if <paramref name="style"/> includes the <see cref="F:System.Globalization.NumberStyles.AllowTrailingSign"/> flag. 
                  Parentheses can be used in <paramref name="value"/> to indicate a negative value if <paramref name="style"/> includes the <see cref="F:System.Globalization.NumberStyles.AllowParentheses"/> flag. 
                  However, the negative sign symbol can be used only with zero; otherwise, the method throws an <see cref="T:System.OverflowException"/>.
                  </description>
                </item>
                <item>
                  <term>digits</term>
                  <description>A sequence of digits from 0 through 9.</description>
                </item>
                <item>
                  <term>.</term>
                  <description>
                  A culture-specific decimal point symbol. 
                  The current culture's decimal point symbol can appear in <paramref name="value"/> if <paramref name="style"/> includes the <see cref="F:System.Globalization.NumberStyles.AllowDecimalPoint"/> flag.
                  </description>
                </item>
                <item>
                  <term>,</term>
                  <description>
                  A culture-specific group separator symbol. 
                  The current culture's group separator can appear in <paramref name="value"/> if <paramref name="style"/> includes the <see cref="F:System.Globalization.NumberStyles.AllowThousands"/> flag.</description>
                </item>
                <item>
                  <term>fractional_digits</term>
                  <description>
                  One or more occurrences of the digit 0-9 if <paramref name="style"/> includes the <see cref="F:System.Globalization.NumberStyles.AllowExponent"/> flag, 
                  or one or more occurrences of the digit 0 if it does not. 
                  Fractional digits can appear in <paramref name="value"/> only if <paramref name="style"/> includes the <see cref="F:System.Globalization.NumberStyles.AllowDecimalPoint"/> flag.
                  </description>
                </item>
                <item>
                  <term>E</term>
                  <description>
                  The "e" or "E" character, which indicates that the value is represented in exponential (scientific) notation. 
                  The <paramref name="value"/> parameter can represent a number in exponential notation if <paramref name="style"/> includes the <see cref="F:System.Globalization.NumberStyles.AllowExponent"/> flag.
                  </description>
                </item>
                <item>
                  <term>exponential_digits</term>
                  <description>
                  A sequence of digits from 0 through 9. 
                  The <paramref name="value"/> parameter can represent a number in exponential notation if <paramref name="style"/> includes the <see cref="F:System.Globalization.NumberStyles.AllowExponent"/> flag.
                  </description>
                </item>
                <item><term>hexdigits</term><description>A sequence of hexadecimal digits from 0 through f, or 0 through F.</description></item>
              </list>
              A string with decimal digits only (which corresponds to the <see cref="F:System.Globalization.NumberStyles.None"/> style) always parses successfully. 
              Most of the remaining <see cref="T:System.Globalization.NumberStyles"/> members control elements that may be present, but are not required to be present, in this input string. 
              The following table indicates how individual <see cref="T:System.Globalization.NumberStyles"/> members affect the elements that may be present in <paramref name="value"/>.
              <list type="table">
                <listheader>
                    <term><see cref="T:System.Globalization.NumberStyles"/> value</term>
                    <description>Elements permitted in <paramref name="value"/> in addition to digits</description>
                </listheader>
                <item><term><see cref="F:System.Globalization.NumberStyles.None"/></term><description>The digits element only.</description></item>
                <item><term><see cref="F:System.Globalization.NumberStyles.AllowDecimalPoint"/></term><description>The decimal point (.) and fractional_digits elements. However, if <paramref name="style"/> does not include the <see cref="F:System.Globalization.NumberStyles.AllowExponent"/> flag, fractional_digits must consist of only one or more 0 digits; otherwise, an <see cref="T:System.OverflowException"/> is thrown.</description></item>
                <item><term><see cref="F:System.Globalization.NumberStyles.AllowExponent"/></term><description>The "e" or "E" character, which indicates exponential notation, along with exponential_digits.</description></item>
                <item><term><see cref="F:System.Globalization.NumberStyles.AllowLeadingWhite"/></term><description>The ws element at the start of <paramref name="value"/>.</description></item>
                <item><term><see cref="F:System.Globalization.NumberStyles.AllowTrailingWhite"/></term><description>The ws element at the end of <paramref name="value"/>.</description></item>
                <item><term><see cref="F:System.Globalization.NumberStyles.AllowLeadingSign"/></term><description>The sign element at the start of <paramref name="value"/>.</description></item>
                <item><term><see cref="F:System.Globalization.NumberStyles.AllowTrailingSign"/></term><description>The sign element at the end of <paramref name="value"/>.</description></item>
                <item><term><see cref="F:System.Globalization.NumberStyles.AllowParentheses"/></term><description>The sign element in the form of parentheses enclosing the numeric value.</description></item>
                <item><term><see cref="F:System.Globalization.NumberStyles.AllowThousands"/></term><description>The group separator (,) element. </description></item>
                <item><term><see cref="F:System.Globalization.NumberStyles.AllowCurrencySymbol"/></term><description>The currency ($) element.</description></item>
                <item><term><see cref="F:System.Globalization.NumberStyles.Currency"/></term><description>All elements. However, <paramref name="value"/> cannot represent a hexadecimal number or a number in exponential notation.</description></item>
                <item><term><see cref="F:System.Globalization.NumberStyles.Float"/></term><description>The ws element at the start or end of <paramref name="value"/>, sign at the start of <paramref name="value"/>, and the decimal point (.) symbol. The <paramref name="value"/> parameter can also use exponential notation.</description></item>
                <item><term><see cref="F:System.Globalization.NumberStyles.Number"/></term><description>The ws, sign, group separator (,), and decimal point (.) elements.</description></item>
                <item><term><see cref="F:System.Globalization.NumberStyles.Any"/></term><description>All elements. However, <paramref name="value"/> cannot represent a hexadecimal number.</description></item>
              </list>
              Unlike the other <see cref="T:System.Globalization.NumberStyles"/> values, which allow for, but do not require, the presence of particular style elements in <paramref name="value"/>, the <see cref="F:System.Globalization.NumberStyles.AllowHexSpecifier"/> style value means that the individual numeric characters in <paramref name="value"/> are always interpreted as hexadecimal characters. 
              Valid hexadecimal characters are 0-9, A-F, and a-f. 
              The only other flags that can be combined with the <paramref name="style"/> parameter are <see cref="F:System.Globalization.NumberStyles.AllowLeadingWhite"/> and <see cref="F:System.Globalization.NumberStyles.AllowTrailingWhite"/>. 
              (The <see cref="T:System.Globalization.NumberStyles"/> enumeration includes a composite number style, <see cref="F:System.Globalization.NumberStyles.HexNumber"/>, that includes both white-space flags.)
              <note>
              If <paramref name="value"/> is the string representation of a hexadecimal number, it cannot be preceded by any decoration (such as 0x or &amp;h) that differentiates it as a hexadecimal number. 
              This causes the conversion to fail.
              </note>
              The <paramref name="value"/> parameter is parsed by using the formatting information in a <see cref="T:System.Globalization.NumberFormatInfo"/> object that is initialized for the current system culture. 
              To specify the culture whose formatting information is used for the parse operation, call the <see cref="M:PcapDotNet.Base.UInt48.Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider)"/> overload.
            </remarks>
        </member>
        <member name="M:PcapDotNet.Base.UInt48.Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider)">
            <summary>
            Converts the string representation of a number in a specified style and culture-specific format to its 48-bit unsigned integer equivalent.
            </summary>
            <param name="value">
            A string that represents the number to convert. 
            The string is interpreted by using the style specified by the <paramref name="style"/> parameter.
            </param>
            <param name="style">
            A bitwise combination of enumeration values that indicates the style elements that can be present in <paramref name="value"/>. 
            A typical value to specify is <see cref="F:System.Globalization.NumberStyles.Integer"/>.
            </param>
            <param name="provider">An object that supplies culture-specific formatting information about <paramref name="value"/>.</param>
            <returns>A 48-bit unsigned integer equivalent to the number specified in <paramref name="value"/>.</returns>
            <exception cref="T:System.ArgumentNullException">The <paramref name="value"/> parameter is <see langword="null"/>.</exception>
            <exception cref="T:System.ArgumentException">
              <paramref name="style"/> is not a <see cref="T:System.Globalization.NumberStyles"/> value.
              <para>-or-</para>
              <para><paramref name="style"/> is not a combination of <see cref="F:System.Globalization.NumberStyles.AllowHexSpecifier"/> and <see cref="F:System.Globalization.NumberStyles.HexNumber"/> values.</para>
            </exception>
            <exception cref="T:System.FormatException">The <paramref name="value"/> parameter is not in a format compliant with <paramref name="style"/>.</exception>
            <exception cref="T:System.OverflowException">
              The <paramref name="value"/> parameter represents a number less than <see cref="F:PcapDotNet.Base.UInt48.MinValue"/> or greater than <see cref="F:PcapDotNet.Base.UInt48.MaxValue"/>. 
              <para>-or-</para>
              <para><paramref name="value"/> includes non-zero, fractional digits.</para>
            </exception>
            <remarks>
            The <paramref name="style"/> parameter defines the style elements (such as white space, the positive or negative sign symbol, the group separator symbol, or the decimal point symbol) that are allowed in the s parameter for the parse operation to succeed. 
            It must be a combination of bit flags from the <see cref="T:System.Globalization.NumberStyles"/> enumeration.
            <para>Depending on the value of style, the <paramref name="value"/> parameter may include the following elements:</para>
            <para>[ws][$][sign][digits,]digits[.fractional_digits][E[sign]exponential_digits][ws]</para>
            <para>
              Elements in square brackets ([ and ]) are optional. 
              If <paramref name="style"/> includes <see cref="F:System.Globalization.NumberStyles.AllowHexSpecifier"/>, the <paramref name="value"/> parameter may contain the following elements:
            </para>
            <para>[ws]hexdigits[ws]</para>
            <para>The following table describes each element.</para>
              <list type="table">
                <listheader>
                  <term>Element</term>
                  <description>Description</description>
                </listheader>
                <item>
                  <term>ws</term>
                  <description>
                  Optional white space. 
                  White space can appear at the start of <paramref name="value"/> if <paramref name="style"/> includes the <see cref="F:System.Globalization.NumberStyles.AllowLeadingWhite"/> flag, 
                  and it can appear at the end of <paramref name="style"/> if <paramref name="style"/> includes the <see cref="F:System.Globalization.NumberStyles.AllowTrailingWhite"/> flag.
                  </description>
                </item>
                <item>
                  <term>$</term>
                  <description>
                  A culture-specific currency symbol. 
                  Its position in the string is defined by the <see cref="P:System.Globalization.NumberFormatInfo.CurrencyNegativePattern"/> and <see cref="P:System.Globalization.NumberFormatInfo.CurrencyPositivePattern"/> properties of the <see cref="T:System.Globalization.NumberFormatInfo"/> object that is returned by the <see cref="M:System.IFormatProvider.GetFormat(System.Type)"/> method of the provider parameter. 
                  The currency symbol can appear in <paramref name="value"/> if <paramref name="style"/> includes the <see cref="F:System.Globalization.NumberStyles.AllowCurrencySymbol"/> flag.
                  </description>
                </item>
                <item>
                  <term>sign</term>
                  <description>
                  An optional sign. 
                  The sign can appear at the start of <paramref name="value"/> if <paramref name="style"/> includes the <see cref="F:System.Globalization.NumberStyles.AllowLeadingSign"/> flag, and it can appear at the end of <paramref name="value"/> if <paramref name="style"/> includes the <see cref="F:System.Globalization.NumberStyles.AllowTrailingSign"/> flag. 
                  Parentheses can be used in <paramref name="value"/> to indicate a negative value if <paramref name="style"/> includes the <see cref="F:System.Globalization.NumberStyles.AllowParentheses"/> flag.
                  However, the negative sign symbol can be used only with zero; otherwise, the method throws an <see cref="T:System.OverflowException"/>.
                  </description>
                </item>
                <item><term>digits</term><description>A sequence of digits from 0 through 9.</description></item>
                <item>
                  <term>.</term>
                  <description>
                  A culture-specific decimal point symbol. 
                  The current culture's decimal point symbol can appear in <paramref name="value"/> if <paramref name="style"/> includes the <see cref="F:System.Globalization.NumberStyles.AllowDecimalPoint"/> flag.
                  </description>
                </item>
                <item>
                  <term>,</term>
                  <description>
                  A culture-specific group separator symbol. 
                  The current culture's group separator can appear in <paramref name="value"/> if <paramref name="style"/> includes the <see cref="F:System.Globalization.NumberStyles.AllowThousands"/> flag.</description>
                </item>
                <item>
                  <term>fractional_digits</term>
                  <description>
                  One or more occurrences of the digit 0-9 if <paramref name="style"/> includes the <see cref="F:System.Globalization.NumberStyles.AllowExponent"/> flag, 
                  or one or more occurrences of the digit 0 if it does not. 
                  Fractional digits can appear in <paramref name="value"/> only if <paramref name="style"/> includes the <see cref="F:System.Globalization.NumberStyles.AllowDecimalPoint"/> flag.
                  </description>
                </item>
                <item>
                  <term>E</term>
                  <description>
                  The "e" or "E" character, which indicates that the value is represented in exponential (scientific) notation. 
                  The <paramref name="value"/> parameter can represent a number in exponential notation if <paramref name="style"/> includes the <see cref="F:System.Globalization.NumberStyles.AllowExponent"/> flag.
                  </description>
                </item>
                <item>
                  <term>exponential_digits</term>
                  <description>
                  A sequence of digits from 0 through 9. 
                  The <paramref name="value"/> parameter can represent a number in exponential notation if <paramref name="style"/> includes the <see cref="F:System.Globalization.NumberStyles.AllowExponent"/> flag.
                  </description>
                </item>
                <item><term>hexdigits</term><description>A sequence of hexadecimal digits from 0 through f, or 0 through F.</description></item>
              </list>
              A string with decimal digits only (which corresponds to the <see cref="F:System.Globalization.NumberStyles.None"/> style) always parses successfully. 
              Most of the remaining <see cref="T:System.Globalization.NumberStyles"/> members control elements that may be present, but are not required to be present, in this input string. 
              The following table indicates how individual <see cref="T:System.Globalization.NumberStyles"/> members affect the elements that may be present in <paramref name="value"/>.
              <list type="table">
                <listheader>
                    <term><see cref="T:System.Globalization.NumberStyles"/> value</term>
                    <description>Elements permitted in <paramref name="value"/> in addition to digits</description>
                </listheader>
                <item><term><see cref="F:System.Globalization.NumberStyles.None"/></term><description>The digits element only.</description></item>
                <item><term><see cref="F:System.Globalization.NumberStyles.AllowDecimalPoint"/></term><description>The decimal point (.) and fractional_digits elements. However, if <paramref name="style"/> does not include the <see cref="F:System.Globalization.NumberStyles.AllowExponent"/> flag, fractional_digits must consist of only one or more 0 digits; otherwise, an <see cref="T:System.OverflowException"/> is thrown.</description></item>
                <item><term><see cref="F:System.Globalization.NumberStyles.AllowExponent"/></term><description>The "e" or "E" character, which indicates exponential notation, along with exponential_digits.</description></item>
                <item><term><see cref="F:System.Globalization.NumberStyles.AllowLeadingWhite"/></term><description>The ws element at the start of <paramref name="value"/>.</description></item>
                <item><term><see cref="F:System.Globalization.NumberStyles.AllowTrailingWhite"/></term><description>The ws element at the end of <paramref name="value"/>.</description></item>
                <item><term><see cref="F:System.Globalization.NumberStyles.AllowLeadingSign"/></term><description>The sign element at the start of <paramref name="value"/>.</description></item>
                <item><term><see cref="F:System.Globalization.NumberStyles.AllowTrailingSign"/></term><description>The sign element at the end of <paramref name="value"/>.</description></item>
                <item><term><see cref="F:System.Globalization.NumberStyles.AllowParentheses"/></term><description>The sign element in the form of parentheses enclosing the numeric value.</description></item>
                <item><term><see cref="F:System.Globalization.NumberStyles.AllowThousands"/></term><description>The group separator (,) element. </description></item>
                <item><term><see cref="F:System.Globalization.NumberStyles.AllowCurrencySymbol"/></term><description>The currency ($) element.</description></item>
              <item><term><see cref="F:System.Globalization.NumberStyles.Currency"/></term><description>All elements. However, <paramref name="value"/> cannot represent a hexadecimal number or a number in exponential notation.</description></item>
                <item><term><see cref="F:System.Globalization.NumberStyles.Float"/></term><description>The ws element at the start or end of <paramref name="value"/>, sign at the start of <paramref name="value"/>, and the decimal point (.) symbol. The <paramref name="value"/> parameter can also use exponential notation.</description></item>
                <item><term><see cref="F:System.Globalization.NumberStyles.Number"/></term><description>The ws, sign, group separator (,), and decimal point (.) elements.</description></item>
                <item><term><see cref="F:System.Globalization.NumberStyles.Any"/></term><description>All elements. However, <paramref name="value"/> cannot represent a hexadecimal number.</description></item>
              </list>
              Unlike the other <see cref="T:System.Globalization.NumberStyles"/> values, which allow for, but do not require, the presence of particular style elements in <paramref name="value"/>, the <see cref="F:System.Globalization.NumberStyles.AllowHexSpecifier"/> style value means that the individual numeric characters in <paramref name="value"/> are always interpreted as hexadecimal characters. 
              Valid hexadecimal characters are 0-9, A-F, and a-f. 
              The only other flags that can be combined with the <paramref name="style"/> parameter are <see cref="F:System.Globalization.NumberStyles.AllowLeadingWhite"/> and <see cref="F:System.Globalization.NumberStyles.AllowTrailingWhite"/>. 
              (The <see cref="T:System.Globalization.NumberStyles"/> enumeration includes a composite number style, <see cref="F:System.Globalization.NumberStyles.HexNumber"/>, that includes both white-space flags.) 
              <note>
              If <paramref name="value"/> is the string representation of a hexadecimal number, it cannot be preceded by any decoration (such as 0x or &amp;h) that differentiates it as a hexadecimal number. 
              This causes the conversion to fail.
              </note>
              The <paramref name="provider"/> parameter is an <see cref="T:System.IFormatProvider"/> implementation whose <see cref="M:System.IFormatProvider.GetFormat(System.Type)"/> method returns a <see cref="T:System.Globalization.NumberFormatInfo"/> object that provides culture-specific information about the format of <paramref name="value"/>. 
              There are three ways to use the <paramref name="provider"/> parameter to supply custom formatting information to the parse operation:
              <list type="bullet">
                <item>You can pass the actual <see cref="T:System.Globalization.NumberFormatInfo"/> object that provides formatting information. (Its implementation of <see cref="M:System.IFormatProvider.GetFormat(System.Type)"/> simply returns itself.)</item>
                <item>You can pass a <see cref="T:System.Globalization.CultureInfo"/> object that specifies the culture whose formatting is to be used. Its <see cref="P:System.Globalization.CultureInfo.NumberFormat"/> property provides formatting information.</item>
                <item>You can pass a custom <see cref="T:System.IFormatProvider"/> implementation. Its <see cref="M:System.IFormatProvider.GetFormat(System.Type)"/> method must instantiate and return the <see cref="T:System.Globalization.NumberFormatInfo"/> object that provides formatting information.</item>
              </list>
              If provider is <see langword="null"/>, the <see cref="T:System.Globalization.NumberFormatInfo"/> object for the current culture is used.
            </remarks>
        </member>
        <member name="M:PcapDotNet.Base.UInt48.op_Implicit(System.UInt32)~PcapDotNet.Base.UInt48">
            <summary>
            Converts a 32 bit unsigned integer to a 48 bit unsigned integer by taking all the 32 bits.
            </summary>
            <param name="value">The 32 bit value to convert.</param>
            <returns>The 48 bit value created by taking all the 32 bits of the 32bit value.</returns>
        </member>
        <member name="M:PcapDotNet.Base.UInt48.op_Explicit(System.Int64)~PcapDotNet.Base.UInt48">
            <summary>
            Converts a 64 bit signed integer to a 48 bit unsigned integer by taking the 48 least significant bits.
            </summary>
            <param name="value">The 64 bit value to convert.</param>
            <returns>The 48 bit value created by taking the 48 least significant bits of the 64 bit value.</returns>
        </member>
        <member name="M:PcapDotNet.Base.UInt48.op_Explicit(System.UInt64)~PcapDotNet.Base.UInt48">
            <summary>
            Converts a 64 bit unsigned integer to a 48 bit unsigned integer by taking the 48 least significant bits.
            </summary>
            <param name="value">The 64 bit value to convert.</param>
            <returns>The 48 bit value created by taking the 48 least significant bits of the 64 bit value.</returns>
        </member>
        <member name="M:PcapDotNet.Base.UInt48.op_Implicit(PcapDotNet.Base.UInt48)~System.Int64">
            <summary>
            Converts the 48 bits unsigned integer to a 64 bits signed integer.
            </summary>
            <param name="value">The 48 bit value to convert.</param>
            <returns>The 64 bit value converted from the 48 bit value.</returns>
        </member>
        <member name="M:PcapDotNet.Base.UInt48.op_Implicit(PcapDotNet.Base.UInt48)~System.UInt64">
            <summary>
            Converts the 48 bits unsigned integer to a 64 bits unsigned integer.
            </summary>
            <param name="value">The 48 bit value to convert.</param>
            <returns>The 64 bit value converted from the 48 bit value.</returns>
        </member>
        <member name="M:PcapDotNet.Base.UInt48.op_Explicit(PcapDotNet.Base.UInt48)~System.Byte">
            <summary>
            Converts the 48 bits unsigned integer to an 8 bits unsigned integer.
            </summary>
            <param name="value">The 48 bit value to convert.</param>
            <returns>The 8 bit value converted from the 48 bit value.</returns>
        </member>
        <member name="M:PcapDotNet.Base.UInt48.Equals(PcapDotNet.Base.UInt48)">
            <summary>
            Returns true iff the two values represent the same value.
            </summary>
            <param name="other">The value to compare to.</param>
            <returns>True iff the two values represent the same value.</returns>
        </member>
        <member name="M:PcapDotNet.Base.UInt48.Equals(System.Object)">
            <summary>
            Indicates whether this instance and a specified object are equal.
            </summary>
            <returns>
            true if <paramref name="obj"/> and this instance are the same type and represent the same value; otherwise, false.
            </returns>
            <param name="obj">Another object to compare to. </param><filterpriority>2</filterpriority>
        </member>
        <member name="M:PcapDotNet.Base.UInt48.op_Equality(PcapDotNet.Base.UInt48,PcapDotNet.Base.UInt48)">
            <summary>
            Returns true iff the two values represent the same value.
            </summary>
            <param name="value1">The first value to compare.</param>
            <param name="value2">The second value to compare.</param>
            <returns>True iff the two values represent the same value.</returns>
        </member>
        <member name="M:PcapDotNet.Base.UInt48.op_Inequality(PcapDotNet.Base.UInt48,PcapDotNet.Base.UInt48)">
            <summary>
            Returns true iff the two values represent different values.
            </summary>
            <param name="value1">The first value to compare.</param>
            <param name="value2">The second value to compare.</param>
            <returns>True iff the two values represent different values.</returns>
        </member>
        <member name="M:PcapDotNet.Base.UInt48.GetHashCode">
            <summary>
            Returns the hash code for this instance.
            </summary>
            <returns>
            A 32-bit signed integer that is the hash code for this instance.
            </returns>
        </member>
        <member name="M:PcapDotNet.Base.UInt48.ToString">
            <summary>
            Returns a string representing the value using a default format and an invariant culture format provider.
            </summary>
        </member>
        <member name="M:PcapDotNet.Base.UInt48.ToString(System.String)">
            <summary>
            Returns a string representing the value using the given string format and an invariant culture format provider.
            </summary>
        </member>
        <member name="M:PcapDotNet.Base.UInt48.ToString(System.String,System.IFormatProvider)">
            <summary>
            Returns a string representing the value using the given string format and the given format provider.
            </summary>
        </member>
        <member name="T:PcapDotNet.Base.UIntExtensions">
            <summary>
            Extension method for UInt structure.
            </summary>
        </member>
        <member name="M:PcapDotNet.Base.UIntExtensions.DigitsCount(System.UInt32,System.Double)">
            <summary>
            Returns the number of digits the number will be represented by according to a specific base.
            </summary>
            <param name="value">The number to check for number of digits.</param>
            <param name="digitsBase">The base of the digits.</param>
            <returns>The number of digits the number will be represented by according to a specific base.</returns>
        </member>
        <member name="T:PcapDotNet.Base.UShortExtensions">
            <summary>
            Extension method for UShort structure.
            </summary>
        </member>
        <member name="M:PcapDotNet.Base.UShortExtensions.ReverseEndianity(System.UInt16)">
            <summary>
            Reverses the endianity of the given value.
            </summary>
        </member>
    </members>
</doc>
