<?xml version="1.0" encoding="utf-8"?>
<Type Name="BigInteger" FullName="System.Numerics.BigInteger">
  <TypeSignature Language="C#" Value="public struct BigInteger : IComparable, IComparable&lt;System.Numerics.BigInteger&gt;, IEquatable&lt;System.Numerics.BigInteger&gt;, IFormattable" />
  <TypeSignature Language="ILAsm" Value=".class public sequential ansi sealed beforefieldinit BigInteger extends System.ValueType implements class System.IComparable, class System.IComparable`1&lt;valuetype System.Numerics.BigInteger&gt;, class System.IEquatable`1&lt;valuetype System.Numerics.BigInteger&gt;, class System.IFormattable" />
  <AssemblyInfo>
    <AssemblyName>System.Numerics</AssemblyName>
    <AssemblyVersion>4.0.0.0</AssemblyVersion>
  </AssemblyInfo>
  <Base>
    <BaseTypeName>System.ValueType</BaseTypeName>
  </Base>
  <Interfaces>
    <Interface>
      <InterfaceName>System.IComparable</InterfaceName>
    </Interface>
    <Interface>
      <InterfaceName>System.IComparable&lt;System.Numerics.BigInteger&gt;</InterfaceName>
    </Interface>
    <Interface>
      <InterfaceName>System.IEquatable&lt;System.Numerics.BigInteger&gt;</InterfaceName>
    </Interface>
    <Interface>
      <InterfaceName>System.IFormattable</InterfaceName>
    </Interface>
  </Interfaces>
  <Docs>
    <remarks>
      <attribution license="cc4" from="Microsoft" modified="false" />
      <para>The <see cref="T:System.Numerics.BigInteger" /> type is an immutable type that represents an arbitrarily large integer whose value in theory has no upper or lower bounds. The members of the <see cref="T:System.Numerics.BigInteger" /> type closely parallel those of other integral types (the <see cref="T:System.Byte" />, <see cref="T:System.Int16" />, <see cref="T:System.Int32" />, <see cref="T:System.Int64" />, <see cref="T:System.SByte" />, <see cref="T:System.UInt16" />, <see cref="T:System.UInt32" />, and <see cref="T:System.UInt64" /> types). This type differs from the other integral types in the dnprdnshort, which have a range indicated by their MinValue and MaxValue properties. </para>
      <block subset="none" type="note">
        <para>Because the <see cref="T:System.Numerics.BigInteger" /> type is immutable (see <format type="text/html"><a href="#mutability">Mutability and the BigInteger Structure</a></format>) and because it has no upper or lower bounds, an <see cref="T:System.OutOfMemoryException" /> can be thrown for any operation that causes a <see cref="T:System.Numerics.BigInteger" /> value to grow too large. </para>
      </block>
      <format type="text/html">
        <h2>Instantiating a BigInteger Object</h2>
      </format>
      <para>You can instantiate a <see cref="T:System.Numerics.BigInteger" /> object in several ways:</para>
      <list type="bullet">
        <item>
          <para>You can use the new keyword and provide any integral or floating-point value as a parameter to the <see cref="T:System.Numerics.BigInteger" /> constructor. (Floating-point values are truncated before they are assigned to the <see cref="T:System.Numerics.BigInteger" />.) The following example illustrates how to use the new keyword to instantiate <see cref="T:System.Numerics.BigInteger" /> values.</para>
          <para>code reference: System.Numerics.BigInteger.Class#1</para>
        </item>
        <item>
          <para>You can declare a <see cref="T:System.Numerics.BigInteger" /> variable and assign it a value just as you would any numeric type, as long as that value is an integral type. The following example uses assignment to create a <see cref="T:System.Numerics.BigInteger" /> value from an <see cref="T:System.Int64" />.</para>
          <para>code reference: System.Numerics.BigInteger.Class#2</para>
        </item>
        <item>
          <para>You can assign a decimal or floating-point value to a <see cref="T:System.Numerics.BigInteger" /> object if you cast the value or convert it first. The following example explicitly casts (in C#) or converts (in Visual Basic) a <see cref="T:System.Double" /> and a <see cref="T:System.Decimal" /> value to a <see cref="T:System.Numerics.BigInteger" />.</para>
          <para>code reference: System.Numerics.BigInteger.Class#3</para>
        </item>
      </list>
      <para>These methods enable you to instantiate a <see cref="T:System.Numerics.BigInteger" /> object whose value is in the range of one of the existing numeric types only. You can instantiate a <see cref="T:System.Numerics.BigInteger" /> object whose value can exceed the range of the existing numeric types in one of three ways:</para>
      <list type="bullet">
        <item>
          <para>You can use the new keyword and provide a byte array of any size to the <see cref="M:System.Numerics.BigInteger.#ctor(System.Byte[])" /> constructor. For example:</para>
          <para>code reference: System.Numerics.BigInteger.Class#4</para>
        </item>
        <item>
          <para>You can call the <see cref="Overload:System.Numerics.BigInteger.Parse" /> or <see cref="Overload:System.Numerics.BigInteger.TryParse" /> methods to convert the string representation of a number to a <see cref="T:System.Numerics.BigInteger" />. For example:</para>
          <para>code reference: System.Numerics.BigInteger.Class#5</para>
        </item>
        <item>
          <para>You can call a static (Shared in Visual Basic) <see cref="T:System.Numerics.BigInteger" /> method that performs some operation on a numeric expression and returns a calculated <see cref="T:System.Numerics.BigInteger" /> result. The following example does this by cubing <see cref="F:System.UInt64.MaxValue" /> and assigning the result to a <see cref="T:System.Numerics.BigInteger" />.</para>
          <para>code reference: System.Numerics.BigInteger.Class#6</para>
        </item>
      </list>
      <para>The uninitialized value of a <see cref="T:System.Numerics.BigInteger" /> is <see cref="P:System.Numerics.BigInteger.Zero" />.</para>
      <format type="text/html">
        <h2>Performing Operations on BigInteger Values</h2>
      </format>
      <para>You can use a <see cref="T:System.Numerics.BigInteger" /> instance as you would use any other integral type. <see cref="T:System.Numerics.BigInteger" /> overloads the standard numeric operators to enable you to perform basic mathematical operations such as addition, subtraction, division, multiplication, subtraction, negation, and unary negation. You can also use the standard numeric operators to compare two <see cref="T:System.Numerics.BigInteger" /> values with each other. Like the other integral types, <see cref="T:System.Numerics.BigInteger" /> also supports the bitwise And, Or, XOr, left shift, and right shift operators. For languages that do not support custom operators, the <see cref="T:System.Numerics.BigInteger" /> structure also provides equivalent methods for performing mathematical operations. These include <see cref="M:System.Numerics.BigInteger.Add(System.Numerics.BigInteger,System.Numerics.BigInteger)" />, <see cref="M:System.Numerics.BigInteger.Divide(System.Numerics.BigInteger,System.Numerics.BigInteger)" />, <see cref="M:System.Numerics.BigInteger.Multiply(System.Numerics.BigInteger,System.Numerics.BigInteger)" />, <see cref="M:System.Numerics.BigInteger.Negate(System.Numerics.BigInteger)" />, <see cref="M:System.Numerics.BigInteger.Subtract(System.Numerics.BigInteger,System.Numerics.BigInteger)" />, and several others.</para>
      <para>Many members of the <see cref="T:System.Numerics.BigInteger" /> structure correspond directly to members of the other integral types. In addition, <see cref="T:System.Numerics.BigInteger" /> adds members such as the following:</para>
      <list type="bullet">
        <item>
          <para>
            <see cref="P:System.Numerics.BigInteger.Sign" />, which returns a value that indicates the sign of a <see cref="T:System.Numerics.BigInteger" /> value.</para>
        </item>
        <item>
          <para>
            <see cref="M:System.Numerics.BigInteger.Abs(System.Numerics.BigInteger)" />, which returns the absolute value of a <see cref="T:System.Numerics.BigInteger" /> value.</para>
        </item>
        <item>
          <para>
            <see cref="M:System.Numerics.BigInteger.DivRem(System.Numerics.BigInteger,System.Numerics.BigInteger,System.Numerics.BigInteger@)" />, which returns both the quotient and remainder of a division operation.</para>
        </item>
        <item>
          <para>
            <see cref="M:System.Numerics.BigInteger.GreatestCommonDivisor(System.Numerics.BigInteger,System.Numerics.BigInteger)" />, which returns the greatest common divisor of two <see cref="T:System.Numerics.BigInteger" /> values.</para>
        </item>
      </list>
      <para>Many of these additional members correspond to the members of the <see cref="T:System.Math" /> class, which provides the functionality to work with the primitive numeric types.</para>
      <format type="text/html">
        <a href="#mutability" />
      </format>
      <format type="text/html">
        <h2>Mutability and the BigInteger Structure</h2>
      </format>
      <para>The following example instantiates a <see cref="T:System.Numerics.BigInteger" /> object and then increments its value by one.</para>
      <para>code reference: System.Numerics.BigInteger.Class.Mutability#1</para>
      <para>Although this example appears to modify the value of the existing object, this is not the case. <see cref="T:System.Numerics.BigInteger" /> objects are immutable, which means that internally, the common language runtime actually creates a new <see cref="T:System.Numerics.BigInteger" /> object and assigns it a value one greater than its previous value. This new object is then returned to the caller.</para>
      <block subset="none" type="note">
        <para>The other numeric types in the .NET Framework are also immutable. However, because the <see cref="T:System.Numerics.BigInteger" /> type has no upper or lower bounds, its values can grow extremely large and have a measurable impact on performance. </para>
      </block>
      <para>Although this process is transparent to the caller, it does incur a performance penalty. In some cases, especially when repeated operations are performed in a loop on very large <see cref="T:System.Numerics.BigInteger" /> values, that performance penalty can be significant. For example, in the following example, an operation is performed repetitively up to a million times, and a <see cref="T:System.Numerics.BigInteger" /> value is incremented by one every time the operation succeeds.</para>
      <para>code reference: System.Numerics.BigInteger.Class.Mutability#2</para>
      <para>In such a case, you can improve performance by performing all intermediate assignments to an <see cref="T:System.Int32" /> variable. The final value of the variable can then be assigned to the <see cref="T:System.Numerics.BigInteger" /> object when the loop exits. The following example provides an illustration.</para>
      <para>code reference: System.Numerics.BigInteger.Class.Mutability#3</para>
      <format type="text/html">
        <h2>Working with Byte Arrays and Hexadecimal Strings</h2>
      </format>
      <para>If you convert <see cref="T:System.Numerics.BigInteger" /> values to byte arrays, or if you convert byte arrays to <see cref="T:System.Numerics.BigInteger" /> values, you must consider the order of bytes. The <see cref="T:System.Numerics.BigInteger" /> structure expects the individual bytes in a byte array to appear in little-endian order (that is, the lower-order bytes of the value precede the higher-order bytes). You can round-trip a <see cref="T:System.Numerics.BigInteger" /> value by calling the <see cref="M:System.Numerics.BigInteger.ToByteArray" /> method and then passing the resulting byte array to the <see cref="M:System.Numerics.BigInteger.#ctor(System.Byte[])" /> constructor, as the following example shows.</para>
      <para>code reference: System.Numerics.BigInteger.Class.ByteAndHex#1</para>
      <para>To instantiate a <see cref="T:System.Numerics.BigInteger" /> value from a byte array that represents a value of some other integral type, you can pass the integral value to the <see cref="M:System.BitConverter.GetBytes(System.UInt16)" /> method, and then pass the resulting byte array to the <see cref="M:System.Numerics.BigInteger.#ctor(System.Byte[])" /> constructor. The following example instantiates a <see cref="T:System.Numerics.BigInteger" /> value from a byte array that represents an <see cref="T:System.Int16" /> value.</para>
      <para>code reference: System.Numerics.BigInteger.Class.ByteAndHex#2</para>
      <para>The <see cref="T:System.Numerics.BigInteger" /> structure assumes that negative values are stored by using two's complement representation. Because the <see cref="T:System.Numerics.BigInteger" /> structure represents a numeric value with no fixed length, the <see cref="M:System.Numerics.BigInteger.#ctor(System.Byte[])" /> constructor always interprets the most significant bit of the last byte in the array as a sign bit. To prevent the <see cref="M:System.Numerics.BigInteger.#ctor(System.Byte[])" /> constructor from confusing the two's complement representation of a negative value with the sign and magnitude representation of a positive value, positive values in which the most significant bit of the last byte in the byte array would ordinarily be set should include an additional byte whose value is 0. For example, 0xC0 0xBD 0xF0 0xFF is the little-endian hexadecimal representation of either -1,000,000 or 4,293,967,296. Because the most significant bit of the last byte in this array is on, the value of the byte array would be interpreted by the <see cref="M:System.Numerics.BigInteger.#ctor(System.Byte[])" /> constructor as -1,000,000. To instantiate a <see cref="T:System.Numerics.BigInteger" /> whose value is positive, a byte array whose elements are 0xC0 0xBD 0xF0 0xFF 0x00 must be passed to the constructor. The following example illustrates this.</para>
      <para>code reference: System.Numerics.BigInteger.Class.ByteAndHex#3</para>
      <para>Byte arrays created by the <see cref="M:System.Numerics.BigInteger.ToByteArray" /> method from positive values include this extra zero-value byte. Therefore, the <see cref="T:System.Numerics.BigInteger" /> structure can successfully round-trip values by assigning them to, and then restoring them from, byte arrays, as the following example shows.</para>
      <para>code reference: System.Numerics.BigInteger.Class.ByteAndHex#4</para>
      <para>However, you may need to add this additional zero-value byte to byte arrays that are created dynamically by the developer or that are returned by methods that convert unsigned integers to byte arrays (such as <see cref="M:System.BitConverter.GetBytes(System.UInt16)" />, <see cref="M:System.BitConverter.GetBytes(System.UInt32)" />, and <see cref="M:System.BitConverter.GetBytes(System.UInt64)" />).</para>
      <para>When parsing a hexadecimal string, the <see cref="M:System.Numerics.BigInteger.Parse(System.String,System.Globalization.NumberStyles)" /> and <see cref="M:System.Numerics.BigInteger.Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider)" /> methods assume that if the most significant bit of the first byte in the string is set, or if the first hexadecimal digit of the string represents the lower four bits of a byte value, the value is represented by using two's complement representation. For example, both "FF01" and "F01" represent the decimal value -255. To differentiate positive from negative values, positive values should include a leading zero. The relevant overloads of the <see cref="M:System.Numerics.BigInteger.ToString" /> method, when they are passed the "X" format string, add a leading zero to the returned hexadecimal string for positive values. This makes it possible to round-trip <see cref="T:System.Numerics.BigInteger" /> values by using the <see cref="M:System.Numerics.BigInteger.ToString" /> and <see cref="M:System.Numerics.BigInteger.Parse(System.String)" /> methods, as the following example shows.</para>
      <para>code reference: System.Numerics.BigInteger.Class.ByteAndHex#5</para>
      <para>However, the hexadecimal strings created by calling the ToString methods of the other integral types or the overloads of the <see cref="M:System.Convert.ToString(System.Int32)" /> method that include a <paramref name="toBase" /> parameter do not indicate the sign of the value or the source data type from which the hexadecimal string was derived. Successfully instantiating a <see cref="T:System.Numerics.BigInteger" /> value from such a string requires some additional logic. The following example provides one possible implementation.</para>
      <para>code reference: System.Numerics.BigInteger.Class.ByteAndHex#6</para>
    </remarks>
    <summary>
      <attribution license="cc4" from="Microsoft" modified="false" />
      <para>Represents an arbitrarily large signed integer.</para>
    </summary>
  </Docs>
  <Members>
    <Member MemberName=".ctor">
      <MemberSignature Language="C#" Value="public BigInteger (byte[] value);" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig specialname rtspecialname instance void .ctor(unsigned int8[] value) cil managed" />
      <MemberType>Constructor</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName>System.CLSCompliant(false)</AttributeName>
        </Attribute>
      </Attributes>
      <Parameters>
        <Parameter Name="value" Type="System.Byte[]" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The individual bytes in the <paramref name="value" /> array should be in little-endian order, from lowest-order byte to highest-order byte. For example, the numeric value 1,000,000,000,000 is represented as shown in the following table:</para>
          <list type="table">
            <item>
              <term>
                <para>Hexadecimal string</para>
              </term>
              <description>
                <para>E8D4A51000</para>
              </description>
            </item>
            <item>
              <term>
                <para>Byte array (lowest index first)</para>
              </term>
              <description>
                <para>00 10 A5 D4 E8 00 </para>
              </description>
            </item>
          </list>
          <para>Most methods that convert numeric values to byte arrays, such as <see cref="M:System.Numerics.BigInteger.ToByteArray" /> and <see cref="M:System.BitConverter.GetBytes(System.Int32)" />, return byte arrays in little-endian order.</para>
          <para>The constructor expects positive values in the byte array to use sign-and-magnitude representation, and negative values to use two's complement representation. In other words, if the highest-order bit of the highest-order byte in <paramref name="value" /> is set, the resulting <see cref="T:System.Numerics.BigInteger" /> value is negative. Depending on the source of the byte array, this may cause a positive value to be misinterpreted as a negative value. Byte arrays are typically generated in the following ways:</para>
          <list type="bullet">
            <item>
              <para>By calling the <see cref="M:System.Numerics.BigInteger.ToByteArray" /> method. Because this method returns a byte array with the highest-order bit of the highest-order byte in the array set to zero for positive values, there is no chance of misinterpreting a positive value as negative. Unmodified byte arrays created by the <see cref="M:System.Numerics.BigInteger.ToByteArray" /> method always successfully round-trip when they are passed to the <see cref="M:System.Numerics.BigInteger.#ctor(System.Byte[])" /> constructor.</para>
            </item>
            <item>
              <para>By calling the <see cref="M:System.BitConverter.GetBytes(System.Int32)" /> method and passing it a signed integer as a parameter. Because signed integers handle both sign-and-magnitude representation and two's complement representation, there is no chance of misinterpreting a positive value as negative.</para>
            </item>
            <item>
              <para>By calling the <see cref="M:System.BitConverter.GetBytes(System.Int32)" /> method and passing it an unsigned integer as a parameter. Because unsigned integers are represented by their magnitude only, positive values can be misinterpreted as negative values. To prevent this misinterpretation, you can add a zero-byte value to the end of the array. The example in the next section provides an illustration.</para>
            </item>
            <item>
              <para>By creating a byte array either dynamically or statically without necessarily calling any of the previous methods, or by modifying an existing byte array. To prevent positive values from being misinterpreted as negative values, you can add a zero-byte value to the end of the array.</para>
            </item>
          </list>
          <para>If <paramref name="value" /> is an empty <see cref="T:System.Byte" /> array, the new <see cref="T:System.Numerics.BigInteger" /> object is initialized to a value of <see cref="P:System.Numerics.BigInteger.Zero" />. If <paramref name="value" /> is null, the constructor throws an <see cref="T:System.ArgumentNullException" />. </para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Initializes a new instance of the <see cref="T:System.Numerics.BigInteger" /> structure using the values in a byte array.</para>
        </summary>
        <param name="value">
          <attribution license="cc4" from="Microsoft" modified="false" />An array of byte values in little-endian order.</param>
      </Docs>
    </Member>
    <Member MemberName=".ctor">
      <MemberSignature Language="C#" Value="public BigInteger (decimal value);" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig specialname rtspecialname instance void .ctor(valuetype System.Decimal value) cil managed" />
      <MemberType>Constructor</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Parameters>
        <Parameter Name="value" Type="System.Decimal" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The result of calling this constructor is identical to explicitly assigning a <see cref="T:System.Decimal" /> value to a <see cref="T:System.Numerics.BigInteger" /> variable.</para>
          <para>Calling this constructor can cause data loss; any fractional part of <paramref name="value" /> is truncated when instantiating a <see cref="T:System.Numerics.BigInteger" /> object.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Initializes a new instance of the <see cref="T:System.Numerics.BigInteger" /> structure using a <see cref="T:System.Decimal" /> value.</para>
        </summary>
        <param name="value">
          <attribution license="cc4" from="Microsoft" modified="false" />A decimal number.</param>
      </Docs>
    </Member>
    <Member MemberName=".ctor">
      <MemberSignature Language="C#" Value="public BigInteger (double value);" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig specialname rtspecialname instance void .ctor(float64 value) cil managed" />
      <MemberType>Constructor</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Parameters>
        <Parameter Name="value" Type="System.Double" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Any fractional part of the <paramref name="value" /> parameter is truncated when instantiating a <see cref="T:System.Numerics.BigInteger" /> object.</para>
          <para>Because of the lack of precision of the <see cref="T:System.Double" /> data type, calling this constructor can cause data loss.</para>
          <para>The <see cref="T:System.Numerics.BigInteger" /> value that results from calling this constructor is identical to the value that results from explicitly assigning a <see cref="T:System.Double" /> value to a <see cref="T:System.Numerics.BigInteger" />.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Initializes a new instance of the <see cref="T:System.Numerics.BigInteger" /> structure using a double-precision floating-point value.</para>
        </summary>
        <param name="value">
          <attribution license="cc4" from="Microsoft" modified="false" />A double-precision floating-point value.</param>
      </Docs>
    </Member>
    <Member MemberName=".ctor">
      <MemberSignature Language="C#" Value="public BigInteger (int value);" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig specialname rtspecialname instance void .ctor(int32 value) cil managed" />
      <MemberType>Constructor</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Parameters>
        <Parameter Name="value" Type="System.Int32" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>There is no loss of precision when instantiating a <see cref="T:System.Numerics.BigInteger" /> object by using this constructor.</para>
          <para>The <see cref="T:System.Numerics.BigInteger" /> value that results from calling this constructor is identical to the value that results from assigning an <see cref="T:System.Int32" /> value to a <see cref="T:System.Numerics.BigInteger" />.</para>
          <para>The <see cref="T:System.Numerics.BigInteger" /> structure does not include constructors with a parameter of type <see cref="T:System.Byte" />, <see cref="T:System.Int16" />, <see cref="T:System.SByte" />, or <see cref="T:System.UInt16" />. However, the <see cref="T:System.Int32" /> type supports the implicit conversion of 8-bit and 16-bit signed and unsigned integers to signed 32-bit integers. As a result, this constructor is called if <paramref name="value" /> is any one of these four integral types.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Initializes a new instance of the <see cref="T:System.Numerics.BigInteger" /> structure using a 32-bit signed integer value.</para>
        </summary>
        <param name="value">
          <attribution license="cc4" from="Microsoft" modified="false" />A 32-bit signed integer.</param>
      </Docs>
    </Member>
    <Member MemberName=".ctor">
      <MemberSignature Language="C#" Value="public BigInteger (long value);" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig specialname rtspecialname instance void .ctor(int64 value) cil managed" />
      <MemberType>Constructor</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Parameters>
        <Parameter Name="value" Type="System.Int64" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>There is no loss of precision when instantiating a <see cref="T:System.Numerics.BigInteger" /> object by using this constructor.</para>
          <para>The <see cref="T:System.Numerics.BigInteger" /> value that results from calling this constructor is identical to the value that results from assigning an <see cref="T:System.Int64" /> value to a <see cref="T:System.Numerics.BigInteger" />.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Initializes a new instance of the <see cref="T:System.Numerics.BigInteger" /> structure using a 64-bit signed integer value.</para>
        </summary>
        <param name="value">
          <attribution license="cc4" from="Microsoft" modified="false" />A 64-bit signed integer.</param>
      </Docs>
    </Member>
    <Member MemberName=".ctor">
      <MemberSignature Language="C#" Value="public BigInteger (float value);" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig specialname rtspecialname instance void .ctor(float32 value) cil managed" />
      <MemberType>Constructor</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Parameters>
        <Parameter Name="value" Type="System.Single" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Any fractional part of the <paramref name="value" /> parameter is truncated when instantiating a <see cref="T:System.Numerics.BigInteger" /> object.</para>
          <para>Because of the lack of precision of the <see cref="T:System.Single" /> data type, calling this constructor can result in data loss.</para>
          <para>The <see cref="T:System.Numerics.BigInteger" /> value that results from calling this constructor is identical to the value that results from explicitly assigning a <see cref="T:System.Single" /> value to a <see cref="T:System.Numerics.BigInteger" />.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Initializes a new instance of the <see cref="T:System.Numerics.BigInteger" /> structure using a single-precision floating-point value.</para>
        </summary>
        <param name="value">
          <attribution license="cc4" from="Microsoft" modified="false" />A single-precision floating-point value.</param>
      </Docs>
    </Member>
    <Member MemberName=".ctor">
      <MemberSignature Language="C#" Value="public BigInteger (uint value);" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig specialname rtspecialname instance void .ctor(unsigned int32 value) cil managed" />
      <MemberType>Constructor</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName>System.CLSCompliant(false)</AttributeName>
        </Attribute>
      </Attributes>
      <Parameters>
        <Parameter Name="value" Type="System.UInt32" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>There is no loss of precision when instantiating a <see cref="T:System.Numerics.BigInteger" /> using this constructor.</para>
          <para>The <see cref="T:System.Numerics.BigInteger" /> value that results from calling this constructor is identical to the value that results from assigning a <see cref="T:System.UInt32" /> value to a <see cref="T:System.Numerics.BigInteger" />.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Initializes a new instance of the <see cref="T:System.Numerics.BigInteger" /> structure using an unsigned 32-bit integer value.</para>
        </summary>
        <param name="value">
          <attribution license="cc4" from="Microsoft" modified="false" />An unsigned 32-bit integer value.</param>
      </Docs>
    </Member>
    <Member MemberName=".ctor">
      <MemberSignature Language="C#" Value="public BigInteger (ulong value);" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig specialname rtspecialname instance void .ctor(unsigned int64 value) cil managed" />
      <MemberType>Constructor</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName>System.CLSCompliant(false)</AttributeName>
        </Attribute>
      </Attributes>
      <Parameters>
        <Parameter Name="value" Type="System.UInt64" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>There is no loss of precision when instantiating a <see cref="T:System.Numerics.BigInteger" /> using this constructor.</para>
          <para>The <see cref="T:System.Numerics.BigInteger" /> value that results from calling this constructor is identical to the value that results from assigning a <see cref="T:System.UInt64" /> value to a <see cref="T:System.Numerics.BigInteger" />.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Initializes a new instance of the <see cref="T:System.Numerics.BigInteger" /> structure with an unsigned 64-bit integer value.</para>
        </summary>
        <param name="value">
          <attribution license="cc4" from="Microsoft" modified="false" />An unsigned 64-bit integer.</param>
      </Docs>
    </Member>
    <Member MemberName="Abs">
      <MemberSignature Language="C#" Value="public static System.Numerics.BigInteger Abs (System.Numerics.BigInteger value);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig valuetype System.Numerics.BigInteger Abs(valuetype System.Numerics.BigInteger value) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Numerics.BigInteger</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Numerics.BigInteger" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The absolute value of a number is that number without its sign, as shown in the following table.</para>
          <list type="table">
            <listheader>
              <item>
                <term>
                  <para>
                    <paramref name="value" /> parameter</para>
                </term>
                <description>
                  <para>Return value</para>
                </description>
              </item>
            </listheader>
            <item>
              <term>
                <para>
                  <paramref name="value" /> &gt;= 0</para>
              </term>
              <description>
                <para>
                  <paramref name="value" />
                </para>
              </description>
            </item>
            <item>
              <term>
                <para>
                  <paramref name="value" /> &lt; 0</para>
              </term>
              <description>
                <para>
                  <paramref name="value" /> * -1</para>
              </description>
            </item>
          </list>
          <para>The <see cref="M:System.Numerics.BigInteger.Abs(System.Numerics.BigInteger)" /> method is equivalent to the <see cref="M:System.Math.Abs(System.Decimal)" /> method for the primitive numeric types.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Gets the absolute value of a <see cref="T:System.Numerics.BigInteger" /> object.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The absolute value of <paramref name="value" />.</para>
        </returns>
        <param name="value">
          <attribution license="cc4" from="Microsoft" modified="false" />A number.</param>
      </Docs>
    </Member>
    <Member MemberName="Add">
      <MemberSignature Language="C#" Value="public static System.Numerics.BigInteger Add (System.Numerics.BigInteger left, System.Numerics.BigInteger right);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig valuetype System.Numerics.BigInteger Add(valuetype System.Numerics.BigInteger left, valuetype System.Numerics.BigInteger right) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Numerics.BigInteger</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="left" Type="System.Numerics.BigInteger" />
        <Parameter Name="right" Type="System.Numerics.BigInteger" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Languages that do not support operator overloading or custom operators can use the <see cref="M:System.Numerics.BigInteger.Add(System.Numerics.BigInteger,System.Numerics.BigInteger)" /> method to perform addition using <see cref="T:System.Numerics.BigInteger" /> values.</para>
          <para>The <see cref="M:System.Numerics.BigInteger.Add(System.Numerics.BigInteger,System.Numerics.BigInteger)" /> method is a useful substitute for the addition operator when instantiating a <see cref="T:System.Numerics.BigInteger" /> variable by assigning it a sum that results from addition, as shown in the following example.</para>
          <para>code reference: System.Numerics.BigInteger.OperationMethods#2</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Adds two <see cref="T:System.Numerics.BigInteger" /> values and returns the result.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The sum of <paramref name="left" /> and <paramref name="right" />.</para>
        </returns>
        <param name="left">
          <attribution license="cc4" from="Microsoft" modified="false" />The first value to add.</param>
        <param name="right">
          <attribution license="cc4" from="Microsoft" modified="false" />The second value to add.</param>
      </Docs>
    </Member>
    <Member MemberName="Compare">
      <MemberSignature Language="C#" Value="public static int Compare (System.Numerics.BigInteger left, System.Numerics.BigInteger right);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig int32 Compare(valuetype System.Numerics.BigInteger left, valuetype System.Numerics.BigInteger right) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="left" Type="System.Numerics.BigInteger" />
        <Parameter Name="right" Type="System.Numerics.BigInteger" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Although the <see cref="T:System.Numerics.BigInteger" /> type has no fixed range, comparisons of <see cref="T:System.Numerics.BigInteger" /> values are not characterized by the lack of precision that characterizes the comparison of floating-point numbers. The following example compares two <see cref="T:System.Numerics.BigInteger" /> values that differ by one and that each have 1,896 digits. The <see cref="M:System.Numerics.BigInteger.Compare(System.Numerics.BigInteger,System.Numerics.BigInteger)" /> method correctly reports that the two values are not equal.</para>
          <para>code reference: System.Numerics.BigInteger.Compare#1</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Compares two <see cref="T:System.Numerics.BigInteger" /> values and returns an integer that indicates whether the first value is less than, equal to, or greater than the second value.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>A signed integer that indicates the relative values of <paramref name="left" /> and <paramref name="right" />, as shown in the following table.</para>
          <list type="table">
            <listheader>
              <item>
                <term>
                  <para>Value</para>
                </term>
                <description>
                  <para>Condition</para>
                </description>
              </item>
            </listheader>
            <item>
              <term>
                <para>Less than zero</para>
              </term>
              <description>
                <para>
                  <paramref name="left" /> is less than <paramref name="right" />.</para>
              </description>
            </item>
            <item>
              <term>
                <para>Zero</para>
              </term>
              <description>
                <para>
                  <paramref name="left" /> equals <paramref name="right" />.</para>
              </description>
            </item>
            <item>
              <term>
                <para>Greater than zero</para>
              </term>
              <description>
                <para>
                  <paramref name="left" /> is greater than <paramref name="right" />.</para>
              </description>
            </item>
          </list>
        </returns>
        <param name="left">
          <attribution license="cc4" from="Microsoft" modified="false" />The first value to compare.</param>
        <param name="right">
          <attribution license="cc4" from="Microsoft" modified="false" />The second value to compare.</param>
      </Docs>
    </Member>
    <Member MemberName="CompareTo">
      <MemberSignature Language="C#" Value="public int CompareTo (long other);" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance int32 CompareTo(int64 other) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="other" Type="System.Int64" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>If <paramref name="other" /> is a <see cref="T:System.Byte" />, <see cref="T:System.Int16" />, <see cref="T:System.Int32" />, <see cref="T:System.SByte" />, <see cref="T:System.UInt16" />, or <see cref="T:System.UInt32" /> value, it is implicitly converted to an <see cref="T:System.Int64" /> value when the <see cref="M:System.Numerics.BigInteger.CompareTo(System.Int64)" /> method is called.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Compares this instance to a signed 64-bit integer and returns an integer that indicates whether the value of this instance is less than, equal to, or greater than the value of the signed 64-bit integer.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>A signed integer value that indicates the relationship of this instance to <paramref name="other" />, as shown in the following table.</para>
          <list type="table">
            <listheader>
              <item>
                <term>
                  <para>Return value</para>
                </term>
                <description>
                  <para>Description</para>
                </description>
              </item>
            </listheader>
            <item>
              <term>
                <para>Less than zero</para>
              </term>
              <description>
                <para>The current instance is less than <paramref name="other" />.</para>
              </description>
            </item>
            <item>
              <term>
                <para>Zero</para>
              </term>
              <description>
                <para>The current instance equals <paramref name="other" />.</para>
              </description>
            </item>
            <item>
              <term>
                <para>Greater than zero</para>
              </term>
              <description>
                <para>The current instance is greater than <paramref name="other" />.</para>
              </description>
            </item>
          </list>
        </returns>
        <param name="other">
          <attribution license="cc4" from="Microsoft" modified="false" />The signed 64-bit integer to compare.</param>
      </Docs>
    </Member>
    <Member MemberName="CompareTo">
      <MemberSignature Language="C#" Value="public int CompareTo (System.Numerics.BigInteger other);" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig newslot virtual instance int32 CompareTo(valuetype System.Numerics.BigInteger other) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="other" Type="System.Numerics.BigInteger" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>This overload of the <see cref="Overload:System.Numerics.BigInteger.CompareTo" /> method implements the <see cref="M:System.IComparable`1.CompareTo(`0)" /> method. It is used by generic collection objects to order the items in the collection.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Compares this instance to a second <see cref="T:System.Numerics.BigInteger" /> and returns an integer that indicates whether the value of this instance is less than, equal to, or greater than the value of the specified object.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>A signed integer value that indicates the relationship of this instance to <paramref name="other" />, as shown in the following table.</para>
          <list type="table">
            <listheader>
              <item>
                <term>
                  <para>Return value</para>
                </term>
                <description>
                  <para>Description</para>
                </description>
              </item>
            </listheader>
            <item>
              <term>
                <para>Less than zero</para>
              </term>
              <description>
                <para>The current instance is less than <paramref name="other" />.</para>
              </description>
            </item>
            <item>
              <term>
                <para>Zero</para>
              </term>
              <description>
                <para>The current instance equals <paramref name="other" />.</para>
              </description>
            </item>
            <item>
              <term>
                <para>Greater than zero</para>
              </term>
              <description>
                <para>The current instance is greater than <paramref name="other" />.</para>
              </description>
            </item>
          </list>
        </returns>
        <param name="other">
          <attribution license="cc4" from="Microsoft" modified="false" />The object to compare.</param>
      </Docs>
    </Member>
    <Member MemberName="CompareTo">
      <MemberSignature Language="C#" Value="public int CompareTo (object obj);" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig newslot virtual instance int32 CompareTo(object obj) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="obj" Type="System.Object" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>This overload of the <see cref="Overload:System.Numerics.BigInteger.CompareTo" /> method implements the <see cref="M:System.IComparable.CompareTo(System.Object)" /> method. It is used by non-generic collection objects to order the items in the collection.</para>
          <para>The <paramref name="obj" /> parameter must be one of the following:</para>
          <list type="bullet">
            <item>
              <para>An object whose run-time type is <see cref="T:System.Numerics.BigInteger" />.</para>
            </item>
            <item>
              <para>An <see cref="T:System.Object" /> variable whose value is null. If the value of the <paramref name="obj" /> parameter is null, the method returns 1, which indicates that that the current instance is greater than <paramref name="obj" />.</para>
            </item>
          </list>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Compares this instance to a specified object and returns an integer that indicates whether the value of this instance is less than, equal to, or greater than the value of the specified object.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>A signed integer that indicates the relationship of the current instance to the <paramref name="obj" /> parameter, as shown in the following table.</para>
          <list type="table">
            <listheader>
              <item>
                <term>
                  <para>Return value</para>
                </term>
                <description>
                  <para>Description</para>
                </description>
              </item>
            </listheader>
            <item>
              <term>
                <para>Less than zero</para>
              </term>
              <description>
                <para>The current instance is less than <paramref name="obj" />.</para>
              </description>
            </item>
            <item>
              <term>
                <para>Zero</para>
              </term>
              <description>
                <para>The current instance equals <paramref name="obj" />.</para>
              </description>
            </item>
            <item>
              <term>
                <para>Greater than zero</para>
              </term>
              <description>
                <para>The current instance is greater than <paramref name="obj" />, or the <paramref name="obj" /> parameter is null. </para>
              </description>
            </item>
          </list>
        </returns>
        <param name="obj">
          <attribution license="cc4" from="Microsoft" modified="false" />The object to compare.</param>
      </Docs>
    </Member>
    <Member MemberName="CompareTo">
      <MemberSignature Language="C#" Value="public int CompareTo (ulong other);" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance int32 CompareTo(unsigned int64 other) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName>System.CLSCompliant(false)</AttributeName>
        </Attribute>
      </Attributes>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="other" Type="System.UInt64" />
      </Parameters>
      <Docs>
        <remarks>To be added.</remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Compares this instance to an unsigned 64-bit integer and returns an integer that indicates whether the value of this instance is less than, equal to, or greater than the value of the unsigned 64-bit integer.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>A signed integer that indicates the relative value of this instance and <paramref name="other" />, as shown in the following table.</para>
          <list type="table">
            <listheader>
              <item>
                <term>
                  <para>Return value</para>
                </term>
                <description>
                  <para>Description</para>
                </description>
              </item>
            </listheader>
            <item>
              <term>
                <para>Less than zero</para>
              </term>
              <description>
                <para>The current instance is less than <paramref name="other" />.</para>
              </description>
            </item>
            <item>
              <term>
                <para>Zero</para>
              </term>
              <description>
                <para>The current instance equals <paramref name="other" />.</para>
              </description>
            </item>
            <item>
              <term>
                <para>Greater than zero</para>
              </term>
              <description>
                <para>The current instance is greater than <paramref name="other" />.</para>
              </description>
            </item>
          </list>
        </returns>
        <param name="other">
          <attribution license="cc4" from="Microsoft" modified="false" />The unsigned 64-bit integer to compare.</param>
      </Docs>
    </Member>
    <Member MemberName="Divide">
      <MemberSignature Language="C#" Value="public static System.Numerics.BigInteger Divide (System.Numerics.BigInteger dividend, System.Numerics.BigInteger divisor);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig valuetype System.Numerics.BigInteger Divide(valuetype System.Numerics.BigInteger dividend, valuetype System.Numerics.BigInteger divisor) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Numerics.BigInteger</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="dividend" Type="System.Numerics.BigInteger" />
        <Parameter Name="divisor" Type="System.Numerics.BigInteger" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The <see cref="M:System.Numerics.BigInteger.Divide(System.Numerics.BigInteger,System.Numerics.BigInteger)" /> method performs integer division; any remainder that results from the division is discarded. To perform integer division while preserving the remainder, call the <see cref="M:System.Numerics.BigInteger.DivRem(System.Numerics.BigInteger,System.Numerics.BigInteger,System.Numerics.BigInteger@)" /> method. To retrieve only the remainder, call the <see cref="M:System.Numerics.BigInteger.Remainder(System.Numerics.BigInteger,System.Numerics.BigInteger)" /> method.</para>
          <para>The <see cref="M:System.Numerics.BigInteger.Divide(System.Numerics.BigInteger,System.Numerics.BigInteger)" /> method can be used by languages that do not support operator overloading. Its behavior is identical to division using the division operator.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Divides one <see cref="T:System.Numerics.BigInteger" /> value by another and returns the result.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The quotient of the division.</para>
        </returns>
        <param name="dividend">
          <attribution license="cc4" from="Microsoft" modified="false" />The value to be divided.</param>
        <param name="divisor">
          <attribution license="cc4" from="Microsoft" modified="false" />The value to divide by.</param>
      </Docs>
    </Member>
    <Member MemberName="DivRem">
      <MemberSignature Language="C#" Value="public static System.Numerics.BigInteger DivRem (System.Numerics.BigInteger dividend, System.Numerics.BigInteger divisor, out System.Numerics.BigInteger remainder);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig valuetype System.Numerics.BigInteger DivRem(valuetype System.Numerics.BigInteger dividend, valuetype System.Numerics.BigInteger divisor, valuetype System.Numerics.BigInteger remainder) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Numerics.BigInteger</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="dividend" Type="System.Numerics.BigInteger" />
        <Parameter Name="divisor" Type="System.Numerics.BigInteger" />
        <Parameter Name="remainder" Type="System.Numerics.BigInteger&amp;" RefType="out" />
      </Parameters>
      <Docs>
        <param name="dividend">To be added.</param>
        <param name="divisor">To be added.</param>
        <param name="remainder">To be added.</param>
        <summary>To be added.</summary>
        <returns>To be added.</returns>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="Equals">
      <MemberSignature Language="C#" Value="public bool Equals (long other);" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance bool Equals(int64 other) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="other" Type="System.Int64" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>If <paramref name="other" /> is a <see cref="T:System.Byte" />, <see cref="T:System.Int16" />, <see cref="T:System.Int32" />, <see cref="T:System.SByte" />, <see cref="T:System.UInt16" />, or <see cref="T:System.UInt32" /> value, it is implicitly converted to an <see cref="T:System.Int64" /> value when the method is called.</para>
          <para>To determine the relationship between the two objects instead of just testing for equality, call the <see cref="M:System.Numerics.BigInteger.CompareTo(System.Int64)" /> method.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Returns a value that indicates whether the current instance and a signed 64-bit integer have the same value.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>true if the signed 64-bit integer and the current instance have the same value; otherwise, false.</para>
        </returns>
        <param name="other">
          <attribution license="cc4" from="Microsoft" modified="false" />The signed 64-bit integer value to compare.</param>
      </Docs>
    </Member>
    <Member MemberName="Equals">
      <MemberSignature Language="C#" Value="public bool Equals (System.Numerics.BigInteger other);" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig newslot virtual instance bool Equals(valuetype System.Numerics.BigInteger other) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="other" Type="System.Numerics.BigInteger" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>This method implements the <see cref="T:System.IEquatable`1" /> interface and performs slightly better than <see cref="M:System.Numerics.BigInteger.Equals(System.Object)" /> because it does not have to convert the <paramref name="other" /> parameter to a <see cref="T:System.Numerics.BigInteger" /> object.</para>
          <para>To determine the relationship between the two <see cref="T:System.Numerics.BigInteger" /> objects instead of just testing for equality, call the <see cref="M:System.Numerics.BigInteger.CompareTo(System.Numerics.BigInteger)" /> method.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Returns a value that indicates whether the current instance and a specified <see cref="T:System.Numerics.BigInteger" /> object have the same value.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>true if this <see cref="T:System.Numerics.BigInteger" /> object and <paramref name="other" /> have the same value; otherwise, false.</para>
        </returns>
        <param name="other">
          <attribution license="cc4" from="Microsoft" modified="false" />The object to compare.</param>
      </Docs>
    </Member>
    <Member MemberName="Equals">
      <MemberSignature Language="C#" Value="public override bool Equals (object obj);" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance bool Equals(object obj) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="obj" Type="System.Object" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>If the <paramref name="obj" /> parameter is not a <see cref="T:System.Numerics.BigInteger" /> value, but it is a data type for which an implicit conversion is defined, the <see cref="M:System.Numerics.BigInteger.Equals(System.Object)" /> method converts <paramref name="obj" /> to a <see cref="T:System.Numerics.BigInteger" /> value before it performs the comparison. If <paramref name="obj" /> is not a <see cref="T:System.Numerics.BigInteger" /> value and cannot be implicitly converted to <see cref="T:System.Numerics.BigInteger" />, the method returns false. If no conversion from <paramref name="obj" /> to a <see cref="T:System.Numerics.BigInteger" /> value exists, the method does not throw an exception; instead, it returns false.</para>
          <para>To determine the relationship between the two objects instead of just testing for equality, call the <see cref="M:System.Numerics.BigInteger.CompareTo(System.Object)" /> method. </para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Returns a value that indicates whether the current instance and a specified object have the same value.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>true if the <paramref name="obj" /> parameter is a <see cref="T:System.Numerics.BigInteger" /> object or a type capable of implicit conversion to a <see cref="T:System.Numerics.BigInteger" /> value, and its value is equal to the value of the current <see cref="T:System.Numerics.BigInteger" /> object; otherwise, false.</para>
        </returns>
        <param name="obj">
          <attribution license="cc4" from="Microsoft" modified="false" />The object to compare. </param>
      </Docs>
    </Member>
    <Member MemberName="Equals">
      <MemberSignature Language="C#" Value="public bool Equals (ulong other);" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance bool Equals(unsigned int64 other) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName>System.CLSCompliant(false)</AttributeName>
        </Attribute>
      </Attributes>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="other" Type="System.UInt64" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>To determine the relationship between the two objects instead of just testing for equality, call the <see cref="M:System.Numerics.BigInteger.CompareTo(System.UInt64)" /> method.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Returns a value that indicates whether the current instance and an unsigned 64-bit integer have the same value.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>true if the current instance and the unsigned 64-bit integer have the same value; otherwise, false.</para>
        </returns>
        <param name="other">
          <attribution license="cc4" from="Microsoft" modified="false" />The unsigned 64-bit integer to compare.</param>
      </Docs>
    </Member>
    <Member MemberName="GetHashCode">
      <MemberSignature Language="C#" Value="public override int GetHashCode ();" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance int32 GetHashCode() cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters />
      <Docs>
        <remarks>To be added.</remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Returns the hash code for the current <see cref="T:System.Numerics.BigInteger" /> object.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>A 32-bit signed integer hash code.</para>
        </returns>
      </Docs>
    </Member>
    <Member MemberName="GreatestCommonDivisor">
      <MemberSignature Language="C#" Value="public static System.Numerics.BigInteger GreatestCommonDivisor (System.Numerics.BigInteger left, System.Numerics.BigInteger right);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig valuetype System.Numerics.BigInteger GreatestCommonDivisor(valuetype System.Numerics.BigInteger left, valuetype System.Numerics.BigInteger right) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Numerics.BigInteger</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="left" Type="System.Numerics.BigInteger" />
        <Parameter Name="right" Type="System.Numerics.BigInteger" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The greatest common divisor is the largest number into which the two <see cref="T:System.Numerics.BigInteger" /> values can be divided without returning a remainder.</para>
          <para>If the <paramref name="left" /> and <paramref name="right" /> parameters are non-zero numbers, the method always returns at least a value of 1 because all numbers can be divided by 1. If either parameter is zero, the method returns the absolute value of the non-zero parameter. If both values are zero, the method returns zero.</para>
          <block subset="none" type="note">
            <para>Computing the greatest common divisor of very large values of <paramref name="left" /> and <paramref name="right" /> can be a very time-consuming operation. </para>
          </block>
          <para>The value returned by the <see cref="M:System.Numerics.BigInteger.GreatestCommonDivisor(System.Numerics.BigInteger,System.Numerics.BigInteger)" /> method is always positive regardless of the sign of the <paramref name="left" /> and <paramref name="right" /> parameters.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Finds the greatest common divisor of two <see cref="T:System.Numerics.BigInteger" /> values.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The greatest common divisor of <paramref name="left" /> and <paramref name="right" />.</para>
        </returns>
        <param name="left">
          <attribution license="cc4" from="Microsoft" modified="false" />The first value.</param>
        <param name="right">
          <attribution license="cc4" from="Microsoft" modified="false" />The second value.</param>
      </Docs>
    </Member>
    <Member MemberName="IsEven">
      <MemberSignature Language="C#" Value="public bool IsEven { get; }" />
      <MemberSignature Language="ILAsm" Value=".property instance bool IsEven" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Docs>
        <value>To be added.</value>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>This property is a convenience feature that indicates whether a <see cref="T:System.Numerics.BigInteger" /> value is evenly divisible by two. It is equivalent to the following expression:</para>
          <para>[C#]</para>
          <code>value % 2 == 0;</code>
          <para>[Visual Basic]</para>
          <code>value Mod 2 = 0</code>
          <para>If the value of the current <see cref="T:System.Numerics.BigInteger" /> object is <see cref="P:System.Numerics.BigInteger.Zero" />, the property returns true.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Indicates whether the value of the current <see cref="T:System.Numerics.BigInteger" /> object is an even number.</para>
        </summary>
      </Docs>
    </Member>
    <Member MemberName="IsOne">
      <MemberSignature Language="C#" Value="public bool IsOne { get; }" />
      <MemberSignature Language="ILAsm" Value=".property instance bool IsOne" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Docs>
        <value>To be added.</value>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>This property offers significantly better performance than other comparisons with one, such as thisBigInteger.Equals(BigInteger.One). </para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Indicates whether the value of the current <see cref="T:System.Numerics.BigInteger" /> object is <see cref="P:System.Numerics.BigInteger.One" />.</para>
        </summary>
      </Docs>
    </Member>
    <Member MemberName="IsPowerOfTwo">
      <MemberSignature Language="C#" Value="public bool IsPowerOfTwo { get; }" />
      <MemberSignature Language="ILAsm" Value=".property instance bool IsPowerOfTwo" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Docs>
        <value>To be added.</value>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>This property determines whether a <see cref="T:System.Numerics.BigInteger" /> value has a single non-zero bit set. This means that it returns true if the value of the current <see cref="T:System.Numerics.BigInteger" /> object is 1 (that is, 2<superscript>0</superscript>) or any greater power of two. It returns false if the value of the current <see cref="T:System.Numerics.BigInteger" /> object is 0.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Indicates whether the value of the current <see cref="T:System.Numerics.BigInteger" /> object is a power of two.</para>
        </summary>
      </Docs>
    </Member>
    <Member MemberName="IsZero">
      <MemberSignature Language="C#" Value="public bool IsZero { get; }" />
      <MemberSignature Language="ILAsm" Value=".property instance bool IsZero" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Docs>
        <value>To be added.</value>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>This property offers significantly better performance than BigInteger.Equals(BigInteger.Zero). </para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Indicates whether the value of the current <see cref="T:System.Numerics.BigInteger" /> object is <see cref="P:System.Numerics.BigInteger.Zero" />.</para>
        </summary>
      </Docs>
    </Member>
    <Member MemberName="Log">
      <MemberSignature Language="C#" Value="public static double Log (System.Numerics.BigInteger value);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig float64 Log(valuetype System.Numerics.BigInteger value) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Double</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Numerics.BigInteger" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The <paramref name="value" /> parameter is specified as a base 10 number.</para>
          <para>The precise return value of this method depends on the sign of <paramref name="value" />, as the following table shows.</para>
          <list type="table">
            <listheader>
              <item>
                <term>
                  <para>Sign of <paramref name="value" /> parameter</para>
                </term>
                <description>
                  <para>Return value</para>
                </description>
              </item>
            </listheader>
            <item>
              <term>
                <para>Positive</para>
              </term>
              <description>
                <para>The natural logarithm of <paramref name="value" />; that is, ln <paramref name="value" />, or log <subscript>e</subscript> <paramref name="value" />.</para>
              </description>
            </item>
            <item>
              <term>
                <para>Zero</para>
              </term>
              <description>
                <para>
                  <see cref="F:System.Double.NegativeInfinity" />. </para>
              </description>
            </item>
            <item>
              <term>
                <para>Negative</para>
              </term>
              <description>
                <para>
                  <see cref="F:System.Double.NaN" />. </para>
              </description>
            </item>
          </list>
          <para>To calculate the base 10 logarithm of a <see cref="T:System.Numerics.BigInteger" /> value, call the <see cref="M:System.Numerics.BigInteger.Log10(System.Numerics.BigInteger)" /> method. To calculate the logarithm of a number in another base, call the <see cref="M:System.Numerics.BigInteger.Log(System.Numerics.BigInteger,System.Double)" /> method.</para>
          <para>You can find the square root of a number by calling the <see cref="M:System.Numerics.BigInteger.Log(System.Numerics.BigInteger)" /> method along with the <see cref="M:System.Math.Exp(System.Double)" /> method. Note that the result is <see cref="F:System.Double.PositiveInfinity" /> if the result is greater than <see cref="F:System.Double.MaxValue" />. The following example calculates the square root of each element in an array of <see cref="T:System.Numerics.BigInteger" /> values.</para>
          <para>code reference: System.Numerics.BigInteger.Log#1</para>
          <para>This method corresponds to the <see cref="M:System.Math.Log(System.Double)" /> method for the primitive numeric types.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Returns the natural (base e) logarithm of a specified number.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The natural (base e) logarithm of <paramref name="value" />, as shown in the table in the Remarks section.</para>
        </returns>
        <param name="value">
          <attribution license="cc4" from="Microsoft" modified="false" />The number whose logarithm is to be found.</param>
      </Docs>
    </Member>
    <Member MemberName="Log">
      <MemberSignature Language="C#" Value="public static double Log (System.Numerics.BigInteger value, double baseValue);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig float64 Log(valuetype System.Numerics.BigInteger value, float64 baseValue) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Double</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Numerics.BigInteger" />
        <Parameter Name="baseValue" Type="System.Double" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The <paramref name="value" /> and <paramref name="baseValue" /> parameters are specified as base 10 numbers.</para>
          <para>The precise return value of the method depends on the sign of <paramref name="value" /> and on the sign and value of <paramref name="baseValue" />, as the following table shows.</para>
          <list type="table">
            <listheader>
              <item>
                <term>
                  <para>
                    <paramref name="value" /> parameter</para>
                </term>
                <description>
                  <para>
                    <paramref name="baseValue" /> parameter</para>
                </description>
                <description>
                  <para>Return value</para>
                </description>
              </item>
            </listheader>
            <item>
              <term>
                <para>
                  <paramref name="value" /> &gt; 0</para>
              </term>
              <description>
                <para>(0 &lt; <paramref name="baseValue" /> &lt; 1) -or-(<paramref name="baseValue" /> &gt; 1)</para>
              </description>
              <description>
                <para>log<subscript>baseValue</subscript>(<paramref name="value" />)</para>
              </description>
            </item>
            <item>
              <term>
                <para>
                  <paramref name="value" /> &lt; 0</para>
              </term>
              <description>
                <para>(any value)</para>
              </description>
              <description>
                <para>
                  <see cref="F:System.Double.NaN" /> </para>
              </description>
            </item>
            <item>
              <term>
                <para>(any value)</para>
              </term>
              <description>
                <para>
                  <paramref name="baseValue" /> &lt; 0</para>
              </description>
              <description>
                <para>
                  <see cref="F:System.Double.NaN" />
                </para>
              </description>
            </item>
            <item>
              <term>
                <para>
                  <paramref name="value" /> != 1</para>
              </term>
              <description>
                <para>
                  <paramref name="baseValue" /> = 0</para>
              </description>
              <description>
                <para>
                  <see cref="F:System.Double.NaN" />
                </para>
              </description>
            </item>
            <item>
              <term>
                <para>
                  <paramref name="value" /> != 1</para>
              </term>
              <description>
                <para>
                  <paramref name="baseValue" /> = <see cref="F:System.Double.PositiveInfinity" /> </para>
              </description>
              <description>
                <para>
                  <see cref="F:System.Double.NaN" />
                </para>
              </description>
            </item>
            <item>
              <term>
                <para>(any value)</para>
              </term>
              <description>
                <para>
                  <paramref name="baseValue" /> = <see cref="F:System.Double.NaN" /></para>
              </description>
              <description>
                <para>
                  <see cref="F:System.Double.NaN" />
                </para>
              </description>
            </item>
            <item>
              <term>
                <para>(any value)</para>
              </term>
              <description>
                <para>
                  <paramref name="baseValue" /> = 1</para>
              </description>
              <description>
                <para>
                  <see cref="F:System.Double.NaN" />
                </para>
              </description>
            </item>
            <item>
              <term>
                <para>
                  <paramref name="value" /> = 0</para>
              </term>
              <description>
                <para>0 &lt; <paramref name="baseValue" /> &lt; 1 </para>
              </description>
              <description>
                <para>
                  <see cref="F:System.Double.PositiveInfinity" />
                </para>
              </description>
            </item>
            <item>
              <term>
                <para>
                  <paramref name="value" /> = 0</para>
              </term>
              <description>
                <para>
                  <paramref name="baseValue" /> &gt; 1</para>
              </description>
              <description>
                <para>
                  <see cref="F:System.Double.PositiveInfinity" />
                </para>
              </description>
            </item>
            <item>
              <term>
                <para>
                  <paramref name="value" /> = 1</para>
              </term>
              <description>
                <para>
                  <paramref name="baseValue" /> = 0</para>
              </description>
              <description>
                <para>0</para>
              </description>
            </item>
            <item>
              <term>
                <para>
                  <paramref name="value" /> = 1</para>
              </term>
              <description>
                <para>
                  <paramref name="baseValue" /> = <see cref="F:System.Double.PositiveInfinity" /></para>
              </description>
              <description>
                <para>0</para>
              </description>
            </item>
          </list>
          <para>To calculate the base 10 logarithm of a <see cref="T:System.Numerics.BigInteger" /> value, call the <see cref="M:System.Numerics.BigInteger.Log10(System.Numerics.BigInteger)" /> method. To calculate the natural logarithm of a number, call the <see cref="M:System.Numerics.BigInteger.Log(System.Numerics.BigInteger)" /> method.</para>
          <para>This method corresponds to the <see cref="M:System.Math.Log(System.Double,System.Double)" /> method for the primitive numeric types.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Returns the logarithm of a specified number in a specified base.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The base <paramref name="baseValue" /> logarithm of <paramref name="value" />, as shown in the table in the Remarks section.</para>
        </returns>
        <param name="value">
          <attribution license="cc4" from="Microsoft" modified="false" />A number whose logarithm is to be found.</param>
        <param name="baseValue">
          <attribution license="cc4" from="Microsoft" modified="false" />The base of the logarithm.</param>
      </Docs>
    </Member>
    <Member MemberName="Log10">
      <MemberSignature Language="C#" Value="public static double Log10 (System.Numerics.BigInteger value);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig float64 Log10(valuetype System.Numerics.BigInteger value) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Double</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Numerics.BigInteger" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The <paramref name="value" /> parameter is specified as a base 10 number.</para>
          <para>The precise return value of the method depends on the sign of <paramref name="value" />, as the following table shows.</para>
          <list type="table">
            <listheader>
              <item>
                <term>
                  <para>Sign of value parameter</para>
                </term>
                <description>
                  <para>Return value</para>
                </description>
              </item>
            </listheader>
            <item>
              <term>
                <para>Positive</para>
              </term>
              <description>
                <para>The base 10 log of <paramref name="value" />; that is, log<subscript>10</subscript><paramref name="value" />.</para>
              </description>
            </item>
            <item>
              <term>
                <para>Zero</para>
              </term>
              <description>
                <para>
                  <see cref="F:System.Double.NegativeInfinity" />. </para>
              </description>
            </item>
            <item>
              <term>
                <para>Negative</para>
              </term>
              <description>
                <para>
                  <see cref="F:System.Double.NaN" />. </para>
              </description>
            </item>
          </list>
          <para>To calculate the natural logarithm of a <see cref="T:System.Numerics.BigInteger" /> value, call the <see cref="M:System.Numerics.BigInteger.Log(System.Numerics.BigInteger)" /> method. To calculate the logarithm of a number in another base, call the <see cref="M:System.Numerics.BigInteger.Log(System.Numerics.BigInteger,System.Double)" /> method.</para>
          <para>This method corresponds to the <see cref="M:System.Math.Log10(System.Double)" /> method for the primitive numeric types.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Returns the base 10 logarithm of a specified number.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The base 10 logarithm of <paramref name="value" />, as shown in the table in the Remarks section.</para>
        </returns>
        <param name="value">
          <attribution license="cc4" from="Microsoft" modified="false" />A number whose logarithm is to be found.</param>
      </Docs>
    </Member>
    <Member MemberName="Max">
      <MemberSignature Language="C#" Value="public static System.Numerics.BigInteger Max (System.Numerics.BigInteger left, System.Numerics.BigInteger right);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig valuetype System.Numerics.BigInteger Max(valuetype System.Numerics.BigInteger left, valuetype System.Numerics.BigInteger right) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Numerics.BigInteger</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="left" Type="System.Numerics.BigInteger" />
        <Parameter Name="right" Type="System.Numerics.BigInteger" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>This method corresponds to the <see cref="M:System.Math.Max(System.Int32,System.Int32)" /> method for primitive numeric types.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Returns the larger of two <see cref="T:System.Numerics.BigInteger" /> values.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The <paramref name="left" /> or <paramref name="right" /> parameter, whichever is larger.</para>
        </returns>
        <param name="left">
          <attribution license="cc4" from="Microsoft" modified="false" />The first value to compare.</param>
        <param name="right">
          <attribution license="cc4" from="Microsoft" modified="false" />The second value to compare.</param>
      </Docs>
    </Member>
    <Member MemberName="Min">
      <MemberSignature Language="C#" Value="public static System.Numerics.BigInteger Min (System.Numerics.BigInteger left, System.Numerics.BigInteger right);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig valuetype System.Numerics.BigInteger Min(valuetype System.Numerics.BigInteger left, valuetype System.Numerics.BigInteger right) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Numerics.BigInteger</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="left" Type="System.Numerics.BigInteger" />
        <Parameter Name="right" Type="System.Numerics.BigInteger" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>This method corresponds to the <see cref="M:System.Math.Min(System.Int32,System.Int32)" /> method for primitive numeric types.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Returns the smaller of two <see cref="T:System.Numerics.BigInteger" /> values.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The <paramref name="left" /> or <paramref name="right" /> parameter, whichever is smaller.</para>
        </returns>
        <param name="left">
          <attribution license="cc4" from="Microsoft" modified="false" />The first value to compare.</param>
        <param name="right">
          <attribution license="cc4" from="Microsoft" modified="false" />The second value to compare.</param>
      </Docs>
    </Member>
    <Member MemberName="MinusOne">
      <MemberSignature Language="C#" Value="public static System.Numerics.BigInteger MinusOne { get; }" />
      <MemberSignature Language="ILAsm" Value=".property valuetype System.Numerics.BigInteger MinusOne" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Numerics.BigInteger</ReturnType>
      </ReturnValue>
      <Docs>
        <value>To be added.</value>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The <see cref="P:System.Numerics.BigInteger.MinusOne" /> property is used to compare a <see cref="T:System.Numerics.BigInteger" /> value to -1 or to assign -1 to a <see cref="T:System.Numerics.BigInteger" /> object.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Gets a value that represents the number negative one (-1).</para>
        </summary>
      </Docs>
    </Member>
    <Member MemberName="ModPow">
      <MemberSignature Language="C#" Value="public static System.Numerics.BigInteger ModPow (System.Numerics.BigInteger value, System.Numerics.BigInteger exponent, System.Numerics.BigInteger modulus);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig valuetype System.Numerics.BigInteger ModPow(valuetype System.Numerics.BigInteger value, valuetype System.Numerics.BigInteger exponent, valuetype System.Numerics.BigInteger modulus) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Numerics.BigInteger</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Numerics.BigInteger" />
        <Parameter Name="exponent" Type="System.Numerics.BigInteger" />
        <Parameter Name="modulus" Type="System.Numerics.BigInteger" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The <see cref="M:System.Numerics.BigInteger.ModPow(System.Numerics.BigInteger,System.Numerics.BigInteger,System.Numerics.BigInteger)" /> method evaluates the following expression:</para>
          <para>
            <math>(baseValue ^ exponent) Mod modulus</math>
          </para>
          <para>To perform exponentiation on <see cref="T:System.Numerics.BigInteger" /> values without modulus division, use the <see cref="M:System.Numerics.BigInteger.Pow(System.Numerics.BigInteger,System.Int32)" /> method.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Performs modulus division on a number raised to the power of another number.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The remainder after dividing <paramref name="value" /><superscript>exponent</superscript> by <paramref name="modulus" />.</para>
        </returns>
        <param name="value">
          <attribution license="cc4" from="Microsoft" modified="false" />The number to raise to the <paramref name="exponent" /> power.</param>
        <param name="exponent">
          <attribution license="cc4" from="Microsoft" modified="false" />The exponent to raise <paramref name="value" /> by.</param>
        <param name="modulus">
          <attribution license="cc4" from="Microsoft" modified="false" />The number by which to divide <paramref name="value" /> raised to the <paramref name="exponent" /> power.</param>
      </Docs>
    </Member>
    <Member MemberName="Multiply">
      <MemberSignature Language="C#" Value="public static System.Numerics.BigInteger Multiply (System.Numerics.BigInteger left, System.Numerics.BigInteger right);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig valuetype System.Numerics.BigInteger Multiply(valuetype System.Numerics.BigInteger left, valuetype System.Numerics.BigInteger right) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Numerics.BigInteger</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="left" Type="System.Numerics.BigInteger" />
        <Parameter Name="right" Type="System.Numerics.BigInteger" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The <see cref="M:System.Numerics.BigInteger.Multiply(System.Numerics.BigInteger,System.Numerics.BigInteger)" /> method is implemented for languages that do not support operator overloading. Its behavior is identical to multiplication using the multiplication operator. In addition, the <see cref="M:System.Numerics.BigInteger.Multiply(System.Numerics.BigInteger,System.Numerics.BigInteger)" /> method is a useful substitute for the multiplication operator when instantiating a <see cref="T:System.Numerics.BigInteger" /> variable by assigning it a product that results from multiplication, as shown in the following example.</para>
          <para>code reference: System.Numerics.BigInteger.OperationMethods#1</para>
          <para>If necessary, this method automatically performs implicit conversion of other integral types to <see cref="T:System.Numerics.BigInteger" /> objects. This is illustrated in the example in the next section, where the <see cref="M:System.Numerics.BigInteger.Multiply(System.Numerics.BigInteger,System.Numerics.BigInteger)" /> method is passed two <see cref="T:System.Int64" /> values.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Returns the product of two <see cref="T:System.Numerics.BigInteger" /> values.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The product of the <paramref name="left" /> and <paramref name="right" /> parameters.</para>
        </returns>
        <param name="left">
          <attribution license="cc4" from="Microsoft" modified="false" />The first number to multiply.</param>
        <param name="right">
          <attribution license="cc4" from="Microsoft" modified="false" />The second number to multiply.</param>
      </Docs>
    </Member>
    <Member MemberName="Negate">
      <MemberSignature Language="C#" Value="public static System.Numerics.BigInteger Negate (System.Numerics.BigInteger value);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig valuetype System.Numerics.BigInteger Negate(valuetype System.Numerics.BigInteger value) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Numerics.BigInteger</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Numerics.BigInteger" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Negation obtains the additive inverse of a number. The additive inverse of a number is a number that produces a value of zero when it is added to the original number.</para>
          <para>The <see cref="M:System.Numerics.BigInteger.Negate(System.Numerics.BigInteger)" /> method is implemented for languages that do not support custom operators. Its behavior is identical to negation using the unary negation operator. In addition, the <see cref="M:System.Numerics.BigInteger.Negate(System.Numerics.BigInteger)" /> method is a useful substitute for the negation operator when instantiating a <see cref="T:System.Numerics.BigInteger" /> variable, as shown in the following example.</para>
          <para>code reference: System.Numerics.BigInteger.OperationMethods#4</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Negates a specified <see cref="T:System.Numerics.BigInteger" /> value.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The result of the <paramref name="value" /> parameter multiplied by negative one (-1).</para>
        </returns>
        <param name="value">
          <attribution license="cc4" from="Microsoft" modified="false" />The value to negate.</param>
      </Docs>
    </Member>
    <Member MemberName="One">
      <MemberSignature Language="C#" Value="public static System.Numerics.BigInteger One { get; }" />
      <MemberSignature Language="ILAsm" Value=".property valuetype System.Numerics.BigInteger One" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Numerics.BigInteger</ReturnType>
      </ReturnValue>
      <Docs>
        <value>To be added.</value>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The <see cref="P:System.Numerics.BigInteger.One" /> property is usually used to compare a <see cref="T:System.Numerics.BigInteger" /> value to 1 or to assign 1 to a <see cref="T:System.Numerics.BigInteger" /> object.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Gets a value that represents the number one (1).</para>
        </summary>
      </Docs>
    </Member>
    <Member MemberName="op_Addition">
      <MemberSignature Language="C#" Value="public static System.Numerics.BigInteger op_Addition (System.Numerics.BigInteger left, System.Numerics.BigInteger right);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig specialname valuetype System.Numerics.BigInteger op_Addition(valuetype System.Numerics.BigInteger left, valuetype System.Numerics.BigInteger right) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Numerics.BigInteger</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="left" Type="System.Numerics.BigInteger" />
        <Parameter Name="right" Type="System.Numerics.BigInteger" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The <see cref="M:System.Numerics.BigInteger.op_Addition(System.Numerics.BigInteger,System.Numerics.BigInteger)" /> method defines the addition operation for <see cref="T:System.Numerics.BigInteger" /> values. It enables code such as the following:</para>
          <para>code reference: System.Numeric.BigInteger.Class#12</para>
          <para>Languages that do not support custom operators can call the <see cref="M:System.Numerics.BigInteger.Add(System.Numerics.BigInteger,System.Numerics.BigInteger)" /> method instead.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Adds the values of two specified <see cref="T:System.Numerics.BigInteger" /> objects.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The sum of <paramref name="left" /> and <paramref name="right" />.</para>
        </returns>
        <param name="left">
          <attribution license="cc4" from="Microsoft" modified="false" />The first value to add.</param>
        <param name="right">
          <attribution license="cc4" from="Microsoft" modified="false" />The second value to add.</param>
      </Docs>
    </Member>
    <Member MemberName="op_BitwiseAnd">
      <MemberSignature Language="C#" Value="public static System.Numerics.BigInteger op_BitwiseAnd (System.Numerics.BigInteger left, System.Numerics.BigInteger right);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig specialname valuetype System.Numerics.BigInteger op_BitwiseAnd(valuetype System.Numerics.BigInteger left, valuetype System.Numerics.BigInteger right) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Numerics.BigInteger</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="left" Type="System.Numerics.BigInteger" />
        <Parameter Name="right" Type="System.Numerics.BigInteger" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The <see cref="M:System.Numerics.BigInteger.op_BitwiseAnd(System.Numerics.BigInteger,System.Numerics.BigInteger)" /> method defines the bitwise And operation for <see cref="T:System.Numerics.BigInteger" /> values. The bitwise And operation sets a result bit only if the corresponding bits in <paramref name="left" /> and <paramref name="right" /> are also set, as shown in the following table.</para>
          <list type="table">
            <listheader>
              <item>
                <term>
                  <para>Bit in <paramref name="left" /></para>
                </term>
                <description>
                  <para>Bit in <paramref name="right" /></para>
                </description>
                <description>
                  <para>Bit in result</para>
                </description>
              </item>
            </listheader>
            <item>
              <term>
                <para>0</para>
              </term>
              <description>
                <para>0</para>
              </description>
              <description>
                <para>0</para>
              </description>
            </item>
            <item>
              <term>
                <para>1</para>
              </term>
              <description>
                <para>0</para>
              </description>
              <description>
                <para>0</para>
              </description>
            </item>
            <item>
              <term>
                <para>1</para>
              </term>
              <description>
                <para>1</para>
              </description>
              <description>
                <para>1</para>
              </description>
            </item>
            <item>
              <term>
                <para>0</para>
              </term>
              <description>
                <para>1</para>
              </description>
              <description>
                <para>0</para>
              </description>
            </item>
          </list>
          <para>The <see cref="M:System.Numerics.BigInteger.op_BitwiseAnd(System.Numerics.BigInteger,System.Numerics.BigInteger)" /> method enables code such as the following:</para>
          <para>code reference: System.Numerics.BigInteger.Operators#1</para>
          <para>The <see cref="M:System.Numerics.BigInteger.op_BitwiseAnd(System.Numerics.BigInteger,System.Numerics.BigInteger)" /> method performs the bitwise And operation on two <see cref="T:System.Numerics.BigInteger" /> values as if they were both in two's complement representation with virtual sign extension. </para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Performs a bitwise And operation on two <see cref="T:System.Numerics.BigInteger" /> values.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The result of the bitwise And operation.</para>
        </returns>
        <param name="left">
          <attribution license="cc4" from="Microsoft" modified="false" />The first value.</param>
        <param name="right">
          <attribution license="cc4" from="Microsoft" modified="false" />The second value.</param>
      </Docs>
    </Member>
    <Member MemberName="op_BitwiseOr">
      <MemberSignature Language="C#" Value="public static System.Numerics.BigInteger op_BitwiseOr (System.Numerics.BigInteger left, System.Numerics.BigInteger right);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig specialname valuetype System.Numerics.BigInteger op_BitwiseOr(valuetype System.Numerics.BigInteger left, valuetype System.Numerics.BigInteger right) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Numerics.BigInteger</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="left" Type="System.Numerics.BigInteger" />
        <Parameter Name="right" Type="System.Numerics.BigInteger" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The <see cref="M:System.Numerics.BigInteger.op_BitwiseOr(System.Numerics.BigInteger,System.Numerics.BigInteger)" /> method defines the bitwise Or operation for <see cref="T:System.Numerics.BigInteger" /> values. The bitwise Or operation sets a result bit only if either or both of the corresponding bits in <paramref name="left" /> and <paramref name="right" /> are set, as shown in the following table.</para>
          <list type="table">
            <listheader>
              <item>
                <term>
                  <para>Bit in <paramref name="left" /></para>
                </term>
                <description>
                  <para>Bit in <paramref name="right" /></para>
                </description>
                <description>
                  <para>Bit in result</para>
                </description>
              </item>
            </listheader>
            <item>
              <term>
                <para>0</para>
              </term>
              <description>
                <para>0</para>
              </description>
              <description>
                <para>0</para>
              </description>
            </item>
            <item>
              <term>
                <para>1</para>
              </term>
              <description>
                <para>0</para>
              </description>
              <description>
                <para>1</para>
              </description>
            </item>
            <item>
              <term>
                <para>1</para>
              </term>
              <description>
                <para>1</para>
              </description>
              <description>
                <para>1</para>
              </description>
            </item>
            <item>
              <term>
                <para>0</para>
              </term>
              <description>
                <para>1</para>
              </description>
              <description>
                <para>1</para>
              </description>
            </item>
          </list>
          <para>The <see cref="M:System.Numerics.BigInteger.op_BitwiseOr(System.Numerics.BigInteger,System.Numerics.BigInteger)" /> method enables code such as the following:</para>
          <para>code reference: System.Numerics.BigInteger.Operators#2</para>
          <para>The <see cref="M:System.Numerics.BigInteger.op_BitwiseOr(System.Numerics.BigInteger,System.Numerics.BigInteger)" /> method performs the bitwise Or operation on two <see cref="T:System.Numerics.BigInteger" /> values as if they were both in two's complement representation with virtual sign extension.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Performs a bitwise Or operation on two <see cref="T:System.Numerics.BigInteger" /> values.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The result of the bitwise Or operation.</para>
        </returns>
        <param name="left">
          <attribution license="cc4" from="Microsoft" modified="false" />The first value.</param>
        <param name="right">
          <attribution license="cc4" from="Microsoft" modified="false" />The second value.</param>
      </Docs>
    </Member>
    <Member MemberName="op_Decrement">
      <MemberSignature Language="C#" Value="public static System.Numerics.BigInteger op_Decrement (System.Numerics.BigInteger value);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig specialname valuetype System.Numerics.BigInteger op_Decrement(valuetype System.Numerics.BigInteger value) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Numerics.BigInteger</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Numerics.BigInteger" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The <see cref="M:System.Numerics.BigInteger.op_Decrement(System.Numerics.BigInteger)" /> method defines the decrement operation for <see cref="T:System.Numerics.BigInteger" /> values. It enables code such as the following:</para>
          <para>code reference: System.Numeric.BigInteger.Class#17</para>
          <para>Languages that do not support custom operators can call the <see cref="M:System.Numerics.BigInteger.Subtract(System.Numerics.BigInteger,System.Numerics.BigInteger)" /> method instead. For example:</para>
          <para>code reference: System.Numerics.BigInteger.Operators#3</para>
          <para>Because <see cref="T:System.Numerics.BigInteger" /> objects are immutable, the <see cref="M:System.Numerics.BigInteger.op_Decrement(System.Numerics.BigInteger)" /> operator creates a new <see cref="T:System.Numerics.BigInteger" /> object whose value is one less than the <see cref="T:System.Numerics.BigInteger" /> object represented by <paramref name="value" />. This means that repeated calls to <see cref="M:System.Numerics.BigInteger.op_Decrement(System.Numerics.BigInteger)" /> may be expensive.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Decrements a <see cref="T:System.Numerics.BigInteger" /> value by 1.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The value of the <paramref name="value" /> parameter decremented by 1.</para>
        </returns>
        <param name="value">
          <attribution license="cc4" from="Microsoft" modified="false" />The value to decrement.</param>
      </Docs>
    </Member>
    <Member MemberName="op_Division">
      <MemberSignature Language="C#" Value="public static System.Numerics.BigInteger op_Division (System.Numerics.BigInteger dividend, System.Numerics.BigInteger divisor);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig specialname valuetype System.Numerics.BigInteger op_Division(valuetype System.Numerics.BigInteger dividend, valuetype System.Numerics.BigInteger divisor) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Numerics.BigInteger</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="dividend" Type="System.Numerics.BigInteger" />
        <Parameter Name="divisor" Type="System.Numerics.BigInteger" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The <see cref="M:System.Numerics.BigInteger.op_Division(System.Numerics.BigInteger,System.Numerics.BigInteger)" /> method defines the division operation for <see cref="T:System.Numerics.BigInteger" /> values. It enables code such as the following:</para>
          <para>code reference: System.Numeric.BigInteger.Class#13</para>
          <para>Languages that do not support custom operators and operator overloading can call the <see cref="M:System.Numerics.BigInteger.Divide(System.Numerics.BigInteger,System.Numerics.BigInteger)" /> method instead.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Divides a specified <see cref="T:System.Numerics.BigInteger" /> value by another specified <see cref="T:System.Numerics.BigInteger" /> value by using integer division.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The integral result of the division.</para>
        </returns>
        <param name="dividend">
          <attribution license="cc4" from="Microsoft" modified="false" />The value to be divided.</param>
        <param name="divisor">
          <attribution license="cc4" from="Microsoft" modified="false" />The value to divide by.</param>
      </Docs>
    </Member>
    <Member MemberName="op_Equality">
      <MemberSignature Language="C#" Value="public static bool op_Equality (long left, System.Numerics.BigInteger right);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig specialname bool op_Equality(int64 left, valuetype System.Numerics.BigInteger right) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="left" Type="System.Int64" />
        <Parameter Name="right" Type="System.Numerics.BigInteger" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The <see cref="M:System.Numerics.BigInteger.op_Equality(System.Int64,System.Numerics.BigInteger)" /> method defines the equality comparison operation for <see cref="T:System.Numerics.BigInteger" /> values. It enables code such as the following:</para>
          <para>code reference: System.Numerics.BigInteger.Operators#4</para>
          <para>Languages that do not support custom operators can call the <see cref="M:System.Numerics.BigInteger.Equals(System.Int64)" /> instance method instead.</para>
          <para>If <paramref name="left" /> is a <see cref="T:System.Byte" />, <see cref="T:System.Int16" />, <see cref="T:System.Int32" />, <see cref="T:System.SByte" />, <see cref="T:System.UInt16" />, or <see cref="T:System.UInt32" /> value, it is implicitly converted to an <see cref="T:System.Int64" /> value when the operation is performed.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Returns a value that indicates whether a signed long integer value and a <see cref="T:System.Numerics.BigInteger" /> value are equal.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>true if the <paramref name="left" /> and <paramref name="right" /> parameters have the same value; otherwise, false.</para>
        </returns>
        <param name="left">
          <attribution license="cc4" from="Microsoft" modified="false" />The first value to compare.</param>
        <param name="right">
          <attribution license="cc4" from="Microsoft" modified="false" />The second value to compare.</param>
      </Docs>
    </Member>
    <Member MemberName="op_Equality">
      <MemberSignature Language="C#" Value="public static bool op_Equality (System.Numerics.BigInteger left, long right);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig specialname bool op_Equality(valuetype System.Numerics.BigInteger left, int64 right) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="left" Type="System.Numerics.BigInteger" />
        <Parameter Name="right" Type="System.Int64" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The <see cref="M:System.Numerics.BigInteger.op_Equality(System.Numerics.BigInteger,System.Int64)" /> method defines the equality comparison operation for <see cref="T:System.Numerics.BigInteger" /> values. It enables code such as the following:</para>
          <para>code reference: System.Numerics.BigInteger.Operators#5</para>
          <para>Languages that do not support custom operators can call the <see cref="M:System.Numerics.BigInteger.Equals(System.Int64)" /> instance method instead.</para>
          <para>If <paramref name="right" /> is a <see cref="T:System.Byte" />, <see cref="T:System.Int16" />, <see cref="T:System.Int32" />, <see cref="T:System.SByte" />, <see cref="T:System.UInt16" />, or <see cref="T:System.UInt32" /> value, it is implicitly converted to an <see cref="T:System.Int64" /> value when the operation is performed.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Returns a value that indicates whether a <see cref="T:System.Numerics.BigInteger" /> value and a signed long integer value are equal.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>true if the <paramref name="left" /> and <paramref name="right" /> parameters have the same value; otherwise, false.</para>
        </returns>
        <param name="left">
          <attribution license="cc4" from="Microsoft" modified="false" />The first value to compare.</param>
        <param name="right">
          <attribution license="cc4" from="Microsoft" modified="false" />The second value to compare.</param>
      </Docs>
    </Member>
    <Member MemberName="op_Equality">
      <MemberSignature Language="C#" Value="public static bool op_Equality (System.Numerics.BigInteger left, System.Numerics.BigInteger right);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig specialname bool op_Equality(valuetype System.Numerics.BigInteger left, valuetype System.Numerics.BigInteger right) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="left" Type="System.Numerics.BigInteger" />
        <Parameter Name="right" Type="System.Numerics.BigInteger" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The <see cref="M:System.Numerics.BigInteger.op_Equality(System.Numerics.BigInteger,System.Numerics.BigInteger)" /> method defines the operation of the equality operator for <see cref="T:System.Numerics.BigInteger" /> values. It enables code such as the following:</para>
          <para>code reference: System.Numeric.BigInteger.Class#19</para>
          <para>Languages that do not support custom operators can call the <see cref="M:System.Numerics.BigInteger.Equals(System.Numerics.BigInteger)" /> instance method instead.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Returns a value that indicates whether the values of two <see cref="T:System.Numerics.BigInteger" /> objects are equal.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>true if the <paramref name="left" /> and <paramref name="right" /> parameters have the same value; otherwise, false.</para>
        </returns>
        <param name="left">
          <attribution license="cc4" from="Microsoft" modified="false" />The first value to compare.</param>
        <param name="right">
          <attribution license="cc4" from="Microsoft" modified="false" />The second value to compare.</param>
      </Docs>
    </Member>
    <Member MemberName="op_Equality">
      <MemberSignature Language="C#" Value="public static bool op_Equality (System.Numerics.BigInteger left, ulong right);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig specialname bool op_Equality(valuetype System.Numerics.BigInteger left, unsigned int64 right) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName>System.CLSCompliant(false)</AttributeName>
        </Attribute>
      </Attributes>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="left" Type="System.Numerics.BigInteger" />
        <Parameter Name="right" Type="System.UInt64" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The <see cref="M:System.Numerics.BigInteger.op_Equality(System.Numerics.BigInteger,System.UInt64)" /> method defines the equality comparison operation for <see cref="T:System.Numerics.BigInteger" /> values. It enables code such as the following:</para>
          <para>code reference: System.Numerics.BigInteger.Operators#6</para>
          <para>Languages that do not support custom operators can call the <see cref="M:System.Numerics.BigInteger.Equals(System.UInt64)" /> instance method instead.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Returns a value that indicates whether a <see cref="T:System.Numerics.BigInteger" /> value and an unsigned long integer value are equal.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>true if the <paramref name="left" /> and <paramref name="right" /> parameters have the same value; otherwise, false.</para>
        </returns>
        <param name="left">
          <attribution license="cc4" from="Microsoft" modified="false" />The first value to compare.</param>
        <param name="right">
          <attribution license="cc4" from="Microsoft" modified="false" />The second value to compare.</param>
      </Docs>
    </Member>
    <Member MemberName="op_Equality">
      <MemberSignature Language="C#" Value="public static bool op_Equality (ulong left, System.Numerics.BigInteger right);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig specialname bool op_Equality(unsigned int64 left, valuetype System.Numerics.BigInteger right) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName>System.CLSCompliant(false)</AttributeName>
        </Attribute>
      </Attributes>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="left" Type="System.UInt64" />
        <Parameter Name="right" Type="System.Numerics.BigInteger" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The <see cref="M:System.Numerics.BigInteger.op_Equality(System.UInt64,System.Numerics.BigInteger)" /> method defines the equality comparison operation for <see cref="T:System.Numerics.BigInteger" /> values. It enables code such as the following:</para>
          <para>code reference: System.Numerics.BigInteger.Operators#7</para>
          <para>Languages that do not support custom operators can call the <see cref="M:System.Numerics.BigInteger.Equals(System.UInt64)" /> instance method instead.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Returns a value that indicates whether an unsigned long integer value and a <see cref="T:System.Numerics.BigInteger" /> value are equal.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>true if the <paramref name="left" /> and <paramref name="right" /> parameters have the same value; otherwise, false.</para>
        </returns>
        <param name="left">
          <attribution license="cc4" from="Microsoft" modified="false" />The first value to compare.</param>
        <param name="right">
          <attribution license="cc4" from="Microsoft" modified="false" />The second value to compare.</param>
      </Docs>
    </Member>
    <Member MemberName="op_ExclusiveOr">
      <MemberSignature Language="C#" Value="public static System.Numerics.BigInteger op_ExclusiveOr (System.Numerics.BigInteger left, System.Numerics.BigInteger right);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig specialname valuetype System.Numerics.BigInteger op_ExclusiveOr(valuetype System.Numerics.BigInteger left, valuetype System.Numerics.BigInteger right) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Numerics.BigInteger</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="left" Type="System.Numerics.BigInteger" />
        <Parameter Name="right" Type="System.Numerics.BigInteger" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The result of a bitwise exclusive Or operation is true if the values of the two bits are different; otherwise, it is false. The following table illustrates the exclusive Or operation.</para>
          <list type="table">
            <listheader>
              <item>
                <term>
                  <para>Bit x in <paramref name="left" /></para>
                </term>
                <description>
                  <para>Bit x in <paramref name="right" /></para>
                </description>
                <description>
                  <para>Return value</para>
                </description>
              </item>
            </listheader>
            <item>
              <term>
                <para>0</para>
              </term>
              <description>
                <para>0</para>
              </description>
              <description>
                <para>0</para>
              </description>
            </item>
            <item>
              <term>
                <para>0</para>
              </term>
              <description>
                <para>1</para>
              </description>
              <description>
                <para>1</para>
              </description>
            </item>
            <item>
              <term>
                <para>1</para>
              </term>
              <description>
                <para>0</para>
              </description>
              <description>
                <para>1</para>
              </description>
            </item>
            <item>
              <term>
                <para>1</para>
              </term>
              <description>
                <para>1</para>
              </description>
              <description>
                <para>0</para>
              </description>
            </item>
          </list>
          <para>The <see cref="M:System.Numerics.BigInteger.op_ExclusiveOr(System.Numerics.BigInteger,System.Numerics.BigInteger)" /> method enables code such as the following:</para>
          <para>code reference: System.Numerics.BigInteger.Operators#8</para>
          <para>The <see cref="M:System.Numerics.BigInteger.op_ExclusiveOr(System.Numerics.BigInteger,System.Numerics.BigInteger)" /> method performs the bitwise exclusive Or operation on two <see cref="T:System.Numerics.BigInteger" /> values as if they were both in two's complement representation with virtual sign extension.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Performs a bitwise exclusive Or (XOr) operation on two <see cref="T:System.Numerics.BigInteger" /> values.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The result of the bitwise Or operation.</para>
        </returns>
        <param name="left">
          <attribution license="cc4" from="Microsoft" modified="false" />The first value.</param>
        <param name="right">
          <attribution license="cc4" from="Microsoft" modified="false" />The second value.</param>
      </Docs>
    </Member>
    <Member MemberName="op_Explicit">
      <MemberSignature Language="C#" Value="public static System.Numerics.BigInteger op_Explicit (decimal value);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig specialname valuetype System.Numerics.BigInteger op_Explicit(valuetype System.Decimal value) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Numerics.BigInteger</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Decimal" />
      </Parameters>
      <Docs>
        <param name="value">To be added.</param>
        <summary>To be added.</summary>
        <returns>To be added.</returns>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="op_Explicit">
      <MemberSignature Language="C#" Value="public static System.Numerics.BigInteger op_Explicit (double value);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig specialname valuetype System.Numerics.BigInteger op_Explicit(float64 value) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Numerics.BigInteger</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Double" />
      </Parameters>
      <Docs>
        <param name="value">To be added.</param>
        <summary>To be added.</summary>
        <returns>To be added.</returns>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="op_Explicit">
      <MemberSignature Language="C#" Value="public static byte op_Explicit (System.Numerics.BigInteger value);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig specialname unsigned int8 op_Explicit(valuetype System.Numerics.BigInteger value) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Byte</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Numerics.BigInteger" />
      </Parameters>
      <Docs>
        <param name="value">To be added.</param>
        <summary>To be added.</summary>
        <returns>To be added.</returns>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="op_Explicit">
      <MemberSignature Language="C#" Value="public static decimal op_Explicit (System.Numerics.BigInteger value);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig specialname valuetype System.Decimal op_Explicit(valuetype System.Numerics.BigInteger value) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Decimal</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Numerics.BigInteger" />
      </Parameters>
      <Docs>
        <param name="value">To be added.</param>
        <summary>To be added.</summary>
        <returns>To be added.</returns>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="op_Explicit">
      <MemberSignature Language="C#" Value="public static double op_Explicit (System.Numerics.BigInteger value);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig specialname float64 op_Explicit(valuetype System.Numerics.BigInteger value) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Double</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Numerics.BigInteger" />
      </Parameters>
      <Docs>
        <param name="value">To be added.</param>
        <summary>To be added.</summary>
        <returns>To be added.</returns>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="op_Explicit">
      <MemberSignature Language="C#" Value="public static short op_Explicit (System.Numerics.BigInteger value);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig specialname int16 op_Explicit(valuetype System.Numerics.BigInteger value) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Int16</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Numerics.BigInteger" />
      </Parameters>
      <Docs>
        <param name="value">To be added.</param>
        <summary>To be added.</summary>
        <returns>To be added.</returns>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="op_Explicit">
      <MemberSignature Language="C#" Value="public static int op_Explicit (System.Numerics.BigInteger value);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig specialname int32 op_Explicit(valuetype System.Numerics.BigInteger value) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Numerics.BigInteger" />
      </Parameters>
      <Docs>
        <param name="value">To be added.</param>
        <summary>To be added.</summary>
        <returns>To be added.</returns>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="op_Explicit">
      <MemberSignature Language="C#" Value="public static long op_Explicit (System.Numerics.BigInteger value);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig specialname int64 op_Explicit(valuetype System.Numerics.BigInteger value) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Int64</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Numerics.BigInteger" />
      </Parameters>
      <Docs>
        <param name="value">To be added.</param>
        <summary>To be added.</summary>
        <returns>To be added.</returns>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="op_Explicit">
      <MemberSignature Language="C#" Value="public static sbyte op_Explicit (System.Numerics.BigInteger value);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig specialname int8 op_Explicit(valuetype System.Numerics.BigInteger value) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName>System.CLSCompliant(false)</AttributeName>
        </Attribute>
      </Attributes>
      <ReturnValue>
        <ReturnType>System.SByte</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Numerics.BigInteger" />
      </Parameters>
      <Docs>
        <param name="value">To be added.</param>
        <summary>To be added.</summary>
        <returns>To be added.</returns>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="op_Explicit">
      <MemberSignature Language="C#" Value="public static float op_Explicit (System.Numerics.BigInteger value);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig specialname float32 op_Explicit(valuetype System.Numerics.BigInteger value) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Single</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Numerics.BigInteger" />
      </Parameters>
      <Docs>
        <param name="value">To be added.</param>
        <summary>To be added.</summary>
        <returns>To be added.</returns>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="op_Explicit">
      <MemberSignature Language="C#" Value="public static ushort op_Explicit (System.Numerics.BigInteger value);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig specialname unsigned int16 op_Explicit(valuetype System.Numerics.BigInteger value) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName>System.CLSCompliant(false)</AttributeName>
        </Attribute>
      </Attributes>
      <ReturnValue>
        <ReturnType>System.UInt16</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Numerics.BigInteger" />
      </Parameters>
      <Docs>
        <param name="value">To be added.</param>
        <summary>To be added.</summary>
        <returns>To be added.</returns>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="op_Explicit">
      <MemberSignature Language="C#" Value="public static uint op_Explicit (System.Numerics.BigInteger value);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig specialname unsigned int32 op_Explicit(valuetype System.Numerics.BigInteger value) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName>System.CLSCompliant(false)</AttributeName>
        </Attribute>
      </Attributes>
      <ReturnValue>
        <ReturnType>System.UInt32</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Numerics.BigInteger" />
      </Parameters>
      <Docs>
        <param name="value">To be added.</param>
        <summary>To be added.</summary>
        <returns>To be added.</returns>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="op_Explicit">
      <MemberSignature Language="C#" Value="public static ulong op_Explicit (System.Numerics.BigInteger value);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig specialname unsigned int64 op_Explicit(valuetype System.Numerics.BigInteger value) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName>System.CLSCompliant(false)</AttributeName>
        </Attribute>
      </Attributes>
      <ReturnValue>
        <ReturnType>System.UInt64</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Numerics.BigInteger" />
      </Parameters>
      <Docs>
        <param name="value">To be added.</param>
        <summary>To be added.</summary>
        <returns>To be added.</returns>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="op_Explicit">
      <MemberSignature Language="C#" Value="public static System.Numerics.BigInteger op_Explicit (float value);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig specialname valuetype System.Numerics.BigInteger op_Explicit(float32 value) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Numerics.BigInteger</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Single" />
      </Parameters>
      <Docs>
        <param name="value">To be added.</param>
        <summary>To be added.</summary>
        <returns>To be added.</returns>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="op_GreaterThan">
      <MemberSignature Language="C#" Value="public static bool op_GreaterThan (long left, System.Numerics.BigInteger right);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig specialname bool op_GreaterThan(int64 left, valuetype System.Numerics.BigInteger right) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="left" Type="System.Int64" />
        <Parameter Name="right" Type="System.Numerics.BigInteger" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The <see cref="M:System.Numerics.BigInteger.op_GreaterThan(System.Int64,System.Numerics.BigInteger)" /> method defines the operation of the greater than operator for <see cref="T:System.Numerics.BigInteger" /> values. It enables code such as the following:</para>
          <para>code reference: System.Numerics.BigInteger.Operators#9</para>
          <para>Languages that do not support custom operators can call the <see cref="M:System.Numerics.BigInteger.CompareTo(System.Int64)" /> instance method instead. Some languages can also call the <see cref="M:System.Numerics.BigInteger.op_GreaterThan(System.Int64,System.Numerics.BigInteger)" /> method directly, as the following example shows.</para>
          <para>code reference: System.Numerics.BigInteger.Operators#10</para>
          <para>If <paramref name="left" /> is a <see cref="T:System.Byte" />, <see cref="T:System.Int16" />, <see cref="T:System.Int32" />, <see cref="T:System.SByte" />, <see cref="T:System.UInt16" />, or <see cref="T:System.UInt32" /> value, it is implicitly converted to an <see cref="T:System.Int64" /> value when the operation is performed.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Returns a value that indicates whether a 64-bit signed integer is greater than a <see cref="T:System.Numerics.BigInteger" /> value.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>true if <paramref name="left" /> is greater than <paramref name="right" />; otherwise, false.</para>
        </returns>
        <param name="left">
          <attribution license="cc4" from="Microsoft" modified="false" />The first value to compare.</param>
        <param name="right">
          <attribution license="cc4" from="Microsoft" modified="false" />The second value to compare.</param>
      </Docs>
    </Member>
    <Member MemberName="op_GreaterThan">
      <MemberSignature Language="C#" Value="public static bool op_GreaterThan (System.Numerics.BigInteger left, long right);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig specialname bool op_GreaterThan(valuetype System.Numerics.BigInteger left, int64 right) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="left" Type="System.Numerics.BigInteger" />
        <Parameter Name="right" Type="System.Int64" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The <see cref="M:System.Numerics.BigInteger.op_GreaterThan(System.Int64,System.Numerics.BigInteger)" /> method defines the operation of the greater than operator for <see cref="T:System.Numerics.BigInteger" /> values. It enables code such as the following:</para>
          <para>code reference: System.Numerics.BigInteger.Operators#11</para>
          <para>Languages that do not support custom operators can call the <see cref="M:System.Numerics.BigInteger.CompareTo(System.Int64)" /> method instead. Some languages can also call the <see cref="M:System.Numerics.BigInteger.op_GreaterThan(System.Numerics.BigInteger,System.Int64)" /> method directly, as the following example shows.</para>
          <para>code reference: System.Numerics.BigInteger.Operators#12</para>
          <para>If <paramref name="right" /> is a <see cref="T:System.Byte" />, <see cref="T:System.Int16" />, <see cref="T:System.Int32" />, <see cref="T:System.SByte" />, <see cref="T:System.UInt16" />, or <see cref="T:System.UInt32" /> value, it is implicitly converted to an <see cref="T:System.Int64" /> value when the operation is performed.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Returns a value that indicates whether a <see cref="T:System.Numerics.BigInteger" /> is greater than a 64-bit signed integer value.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>true if <paramref name="left" /> is greater than <paramref name="right" />; otherwise, false.</para>
        </returns>
        <param name="left">
          <attribution license="cc4" from="Microsoft" modified="false" />The first value to compare.</param>
        <param name="right">
          <attribution license="cc4" from="Microsoft" modified="false" />The second value to compare.</param>
      </Docs>
    </Member>
    <Member MemberName="op_GreaterThan">
      <MemberSignature Language="C#" Value="public static bool op_GreaterThan (System.Numerics.BigInteger left, System.Numerics.BigInteger right);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig specialname bool op_GreaterThan(valuetype System.Numerics.BigInteger left, valuetype System.Numerics.BigInteger right) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="left" Type="System.Numerics.BigInteger" />
        <Parameter Name="right" Type="System.Numerics.BigInteger" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The <see cref="M:System.Numerics.BigInteger.op_GreaterThan(System.Numerics.BigInteger,System.Numerics.BigInteger)" /> method defines the operation of the greater than operator for <see cref="T:System.Numerics.BigInteger" /> values. It enables code such as the following:</para>
          <para>code reference: System.Numeric.BigInteger.Class#20</para>
          <para>Languages that do not support custom operators can call the <see cref="M:System.Numerics.BigInteger.Compare(System.Numerics.BigInteger,System.Numerics.BigInteger)" /> method instead. They can also call the <see cref="M:System.Numerics.BigInteger.op_GreaterThan(System.Numerics.BigInteger,System.Numerics.BigInteger)" /> method directly, as the following example shows.</para>
          <para>code reference: System.Numeric.BigInteger.Class#21</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Returns a value that indicates whether a <see cref="T:System.Numerics.BigInteger" /> value is greater than another <see cref="T:System.Numerics.BigInteger" /> value.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>true if <paramref name="left" /> is greater than <paramref name="right" />; otherwise, false.</para>
        </returns>
        <param name="left">
          <attribution license="cc4" from="Microsoft" modified="false" />The first value to compare.</param>
        <param name="right">
          <attribution license="cc4" from="Microsoft" modified="false" />The second value to compare.</param>
      </Docs>
    </Member>
    <Member MemberName="op_GreaterThan">
      <MemberSignature Language="C#" Value="public static bool op_GreaterThan (System.Numerics.BigInteger left, ulong right);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig specialname bool op_GreaterThan(valuetype System.Numerics.BigInteger left, unsigned int64 right) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName>System.CLSCompliant(false)</AttributeName>
        </Attribute>
      </Attributes>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="left" Type="System.Numerics.BigInteger" />
        <Parameter Name="right" Type="System.UInt64" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The <see cref="M:System.Numerics.BigInteger.op_GreaterThan(System.Int64,System.Numerics.BigInteger)" /> method defines the operation of the greater than operator for <see cref="T:System.Numerics.BigInteger" /> values. It enables code such as the following:</para>
          <para>code reference: System.Numerics.BigInteger.Operators#13</para>
          <para>Languages that do not support custom operators can call the <see cref="M:System.Numerics.BigInteger.CompareTo(System.UInt64)" /> method instead. Some languages can also call the <see cref="M:System.Numerics.BigInteger.op_GreaterThan(System.Numerics.BigInteger,System.UInt64)" /> method directly, as the following example shows.</para>
          <para>code reference: System.Numerics.BigInteger.Operators#14</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Returns a value that indicates whether a <see cref="T:System.Numerics.BigInteger" /> value is greater than a 64-bit unsigned integer.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>true if <paramref name="left" /> is greater than <paramref name="right" />; otherwise, false.</para>
        </returns>
        <param name="left">
          <attribution license="cc4" from="Microsoft" modified="false" />The first value to compare.</param>
        <param name="right">
          <attribution license="cc4" from="Microsoft" modified="false" />The second value to compare.</param>
      </Docs>
    </Member>
    <Member MemberName="op_GreaterThan">
      <MemberSignature Language="C#" Value="public static bool op_GreaterThan (ulong left, System.Numerics.BigInteger right);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig specialname bool op_GreaterThan(unsigned int64 left, valuetype System.Numerics.BigInteger right) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName>System.CLSCompliant(false)</AttributeName>
        </Attribute>
      </Attributes>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="left" Type="System.UInt64" />
        <Parameter Name="right" Type="System.Numerics.BigInteger" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The <see cref="M:System.Numerics.BigInteger.op_GreaterThan(System.UInt64,System.Numerics.BigInteger)" /> method defines the operation of the greater than operator for <see cref="T:System.Numerics.BigInteger" /> values. It enables code such as the following:</para>
          <para>code reference: System.Numerics.BigInteger.Operators#15</para>
          <para>Languages that do not support custom operators can call the <see cref="M:System.Numerics.BigInteger.CompareTo(System.UInt64)" /> method instead. Some languages can also call the <see cref="M:System.Numerics.BigInteger.op_GreaterThan(System.UInt64,System.Numerics.BigInteger)" /> method directly, as the following example shows.</para>
          <para>code reference: System.Numerics.BigInteger.Operators#16</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Returns a value that indicates whether a <see cref="T:System.Numerics.BigInteger" /> value is greater than a 64-bit unsigned integer.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>true if <paramref name="left" /> is greater than <paramref name="right" />; otherwise, false.</para>
        </returns>
        <param name="left">
          <attribution license="cc4" from="Microsoft" modified="false" />The first value to compare.</param>
        <param name="right">
          <attribution license="cc4" from="Microsoft" modified="false" />The second value to compare.</param>
      </Docs>
    </Member>
    <Member MemberName="op_GreaterThanOrEqual">
      <MemberSignature Language="C#" Value="public static bool op_GreaterThanOrEqual (long left, System.Numerics.BigInteger right);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig specialname bool op_GreaterThanOrEqual(int64 left, valuetype System.Numerics.BigInteger right) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="left" Type="System.Int64" />
        <Parameter Name="right" Type="System.Numerics.BigInteger" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The <see cref="M:System.Numerics.BigInteger.op_GreaterThanOrEqual(System.Numerics.BigInteger,System.Numerics.BigInteger)" /> method defines the operation of the greater than or equal to operator for <see cref="T:System.Numerics.BigInteger" /> values. It enables code such as the following:</para>
          <para>code reference: System.Numerics.BigInteger.Operators#17</para>
          <para>Languages that do not support custom operators can call the <see cref="M:System.Numerics.BigInteger.CompareTo(System.Int64)" /> method instead. Some languages can also call the <see cref="M:System.Numerics.BigInteger.op_GreaterThanOrEqual(System.Int64,System.Numerics.BigInteger)" /> method directly, as the following example shows.</para>
          <para>code reference: System.Numerics.BigInteger.Operators#18</para>
          <para>If <paramref name="left" /> is a <see cref="T:System.Byte" />, <see cref="T:System.Int16" />, <see cref="T:System.Int32" />, <see cref="T:System.SByte" />, <see cref="T:System.UInt16" />, or <see cref="T:System.UInt32" /> value, it is implicitly converted to an <see cref="T:System.Int64" /> value when the operation is performed.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Returns a value that indicates whether a 64-bit signed integer is greater than or equal to a <see cref="T:System.Numerics.BigInteger" /> value.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>true if <paramref name="left" /> is greater than <paramref name="right" />; otherwise, false.</para>
        </returns>
        <param name="left">
          <attribution license="cc4" from="Microsoft" modified="false" />The first value to compare.</param>
        <param name="right">
          <attribution license="cc4" from="Microsoft" modified="false" />The second value to compare.</param>
      </Docs>
    </Member>
    <Member MemberName="op_GreaterThanOrEqual">
      <MemberSignature Language="C#" Value="public static bool op_GreaterThanOrEqual (System.Numerics.BigInteger left, long right);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig specialname bool op_GreaterThanOrEqual(valuetype System.Numerics.BigInteger left, int64 right) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="left" Type="System.Numerics.BigInteger" />
        <Parameter Name="right" Type="System.Int64" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The <see cref="M:System.Numerics.BigInteger.op_GreaterThanOrEqual(System.Numerics.BigInteger,System.Numerics.BigInteger)" /> method defines the operation of the greater than or equal to operator for <see cref="T:System.Numerics.BigInteger" /> values. It enables code such as the following:</para>
          <para>code reference: System.Numerics.BigInteger.Operators#19</para>
          <para>Languages that do not support custom operators can call the <see cref="M:System.Numerics.BigInteger.CompareTo(System.Int64)" /> method instead. Some languages can also call the <see cref="M:System.Numerics.BigInteger.op_GreaterThanOrEqual(System.Numerics.BigInteger,System.Int64)" /> method directly, as the following example shows.</para>
          <para>code reference: System.Numerics.BigInteger.Operators#20</para>
          <para>If <paramref name="right" /> is a <see cref="T:System.Byte" />, <see cref="T:System.Int16" />, <see cref="T:System.Int32" />, <see cref="T:System.SByte" />, <see cref="T:System.UInt16" />, or <see cref="T:System.UInt32" /> value, it is implicitly converted to an <see cref="T:System.Int64" /> value when the operation is performed.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Returns a value that indicates whether a <see cref="T:System.Numerics.BigInteger" /> value is greater than or equal to a 64-bit signed integer value.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>true if <paramref name="left" /> is greater than <paramref name="right" />; otherwise, false.</para>
        </returns>
        <param name="left">
          <attribution license="cc4" from="Microsoft" modified="false" />The first value to compare.</param>
        <param name="right">
          <attribution license="cc4" from="Microsoft" modified="false" />The second value to compare.</param>
      </Docs>
    </Member>
    <Member MemberName="op_GreaterThanOrEqual">
      <MemberSignature Language="C#" Value="public static bool op_GreaterThanOrEqual (System.Numerics.BigInteger left, System.Numerics.BigInteger right);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig specialname bool op_GreaterThanOrEqual(valuetype System.Numerics.BigInteger left, valuetype System.Numerics.BigInteger right) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="left" Type="System.Numerics.BigInteger" />
        <Parameter Name="right" Type="System.Numerics.BigInteger" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The <see cref="M:System.Numerics.BigInteger.op_GreaterThanOrEqual(System.Numerics.BigInteger,System.Numerics.BigInteger)" /> method defines the operation of the greater than or equal to operator for <see cref="T:System.Numerics.BigInteger" /> values. It enables code such as the following:</para>
          <para>code reference: System.Numeric.BigInteger.Class#22</para>
          <para>Languages that do not support custom operators can call the <see cref="M:System.Numerics.BigInteger.Compare(System.Numerics.BigInteger,System.Numerics.BigInteger)" /> method instead. Some languages can also call the <see cref="M:System.Numerics.BigInteger.op_GreaterThanOrEqual(System.Numerics.BigInteger,System.Numerics.BigInteger)" /> method directly, as the following example shows.</para>
          <para>code reference: System.Numeric.BigInteger.Class#23</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Returns a value that indicates whether a <see cref="T:System.Numerics.BigInteger" /> value is greater than or equal to another <see cref="T:System.Numerics.BigInteger" /> value.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>true if <paramref name="left" /> is greater than <paramref name="right" />; otherwise, false.</para>
        </returns>
        <param name="left">
          <attribution license="cc4" from="Microsoft" modified="false" />The first value to compare.</param>
        <param name="right">
          <attribution license="cc4" from="Microsoft" modified="false" />The second value to compare.</param>
      </Docs>
    </Member>
    <Member MemberName="op_GreaterThanOrEqual">
      <MemberSignature Language="C#" Value="public static bool op_GreaterThanOrEqual (System.Numerics.BigInteger left, ulong right);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig specialname bool op_GreaterThanOrEqual(valuetype System.Numerics.BigInteger left, unsigned int64 right) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName>System.CLSCompliant(false)</AttributeName>
        </Attribute>
      </Attributes>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="left" Type="System.Numerics.BigInteger" />
        <Parameter Name="right" Type="System.UInt64" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The <see cref="M:System.Numerics.BigInteger.op_GreaterThanOrEqual(System.Numerics.BigInteger,System.Numerics.BigInteger)" /> method defines the operation of the greater than or equal to operator for <see cref="T:System.Numerics.BigInteger" /> values. It enables code such as the following:</para>
          <para>code reference: System.Numerics.BigInteger.Operators#21</para>
          <para>Languages that do not support custom operators can call the <see cref="M:System.Numerics.BigInteger.CompareTo(System.UInt64)" /> method instead. Some languages can also call the <see cref="M:System.Numerics.BigInteger.op_GreaterThanOrEqual(System.Numerics.BigInteger,System.UInt64)" /> method directly, as the following example shows.</para>
          <para>code reference: System.Numerics.BigInteger.Operators#22</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Returns a value that indicates whether a <see cref="T:System.Numerics.BigInteger" /> value is greater than or equal to a 64-bit unsigned integer value.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>true if <paramref name="left" /> is greater than <paramref name="right" />; otherwise, false.</para>
        </returns>
        <param name="left">
          <attribution license="cc4" from="Microsoft" modified="false" />The first value to compare.</param>
        <param name="right">
          <attribution license="cc4" from="Microsoft" modified="false" />The second value to compare.</param>
      </Docs>
    </Member>
    <Member MemberName="op_GreaterThanOrEqual">
      <MemberSignature Language="C#" Value="public static bool op_GreaterThanOrEqual (ulong left, System.Numerics.BigInteger right);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig specialname bool op_GreaterThanOrEqual(unsigned int64 left, valuetype System.Numerics.BigInteger right) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName>System.CLSCompliant(false)</AttributeName>
        </Attribute>
      </Attributes>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="left" Type="System.UInt64" />
        <Parameter Name="right" Type="System.Numerics.BigInteger" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The <see cref="M:System.Numerics.BigInteger.op_GreaterThanOrEqual(System.Numerics.BigInteger,System.Numerics.BigInteger)" /> method defines the operation of the greater than or equal to operator for <see cref="T:System.Numerics.BigInteger" /> values. It enables code such as the following:</para>
          <para>code reference: System.Numerics.BigInteger.Operators#23</para>
          <para>Languages that do not support custom operators can call the <see cref="M:System.Numerics.BigInteger.CompareTo(System.UInt64)" /> method instead. Some languages can also call the <see cref="M:System.Numerics.BigInteger.op_GreaterThanOrEqual(System.UInt64,System.Numerics.BigInteger)" /> method directly, as the following example shows.</para>
          <para>code reference: System.Numerics.BigInteger.Operators#24</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Returns a value that indicates whether a 64-bit unsigned integer is greater than or equal to a <see cref="T:System.Numerics.BigInteger" /> value.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>true if <paramref name="left" /> is greater than <paramref name="right" />; otherwise, false.</para>
        </returns>
        <param name="left">
          <attribution license="cc4" from="Microsoft" modified="false" />The first value to compare.</param>
        <param name="right">
          <attribution license="cc4" from="Microsoft" modified="false" />The second value to compare.</param>
      </Docs>
    </Member>
    <Member MemberName="op_Implicit">
      <MemberSignature Language="C#" Value="public static System.Numerics.BigInteger op_Implicit (byte value);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig specialname valuetype System.Numerics.BigInteger op_Implicit(unsigned int8 value) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Numerics.BigInteger</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Byte" />
      </Parameters>
      <Docs>
        <param name="value">To be added.</param>
        <summary>To be added.</summary>
        <returns>To be added.</returns>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="op_Implicit">
      <MemberSignature Language="C#" Value="public static System.Numerics.BigInteger op_Implicit (short value);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig specialname valuetype System.Numerics.BigInteger op_Implicit(int16 value) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Numerics.BigInteger</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Int16" />
      </Parameters>
      <Docs>
        <param name="value">To be added.</param>
        <summary>To be added.</summary>
        <returns>To be added.</returns>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="op_Implicit">
      <MemberSignature Language="C#" Value="public static System.Numerics.BigInteger op_Implicit (int value);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig specialname valuetype System.Numerics.BigInteger op_Implicit(int32 value) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Numerics.BigInteger</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Int32" />
      </Parameters>
      <Docs>
        <param name="value">To be added.</param>
        <summary>To be added.</summary>
        <returns>To be added.</returns>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="op_Implicit">
      <MemberSignature Language="C#" Value="public static System.Numerics.BigInteger op_Implicit (long value);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig specialname valuetype System.Numerics.BigInteger op_Implicit(int64 value) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Numerics.BigInteger</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Int64" />
      </Parameters>
      <Docs>
        <param name="value">To be added.</param>
        <summary>To be added.</summary>
        <returns>To be added.</returns>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="op_Implicit">
      <MemberSignature Language="C#" Value="public static System.Numerics.BigInteger op_Implicit (sbyte value);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig specialname valuetype System.Numerics.BigInteger op_Implicit(int8 value) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName>System.CLSCompliant(false)</AttributeName>
        </Attribute>
      </Attributes>
      <ReturnValue>
        <ReturnType>System.Numerics.BigInteger</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.SByte" />
      </Parameters>
      <Docs>
        <param name="value">To be added.</param>
        <summary>To be added.</summary>
        <returns>To be added.</returns>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="op_Implicit">
      <MemberSignature Language="C#" Value="public static System.Numerics.BigInteger op_Implicit (ushort value);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig specialname valuetype System.Numerics.BigInteger op_Implicit(unsigned int16 value) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName>System.CLSCompliant(false)</AttributeName>
        </Attribute>
      </Attributes>
      <ReturnValue>
        <ReturnType>System.Numerics.BigInteger</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.UInt16" />
      </Parameters>
      <Docs>
        <param name="value">To be added.</param>
        <summary>To be added.</summary>
        <returns>To be added.</returns>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="op_Implicit">
      <MemberSignature Language="C#" Value="public static System.Numerics.BigInteger op_Implicit (uint value);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig specialname valuetype System.Numerics.BigInteger op_Implicit(unsigned int32 value) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName>System.CLSCompliant(false)</AttributeName>
        </Attribute>
      </Attributes>
      <ReturnValue>
        <ReturnType>System.Numerics.BigInteger</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.UInt32" />
      </Parameters>
      <Docs>
        <param name="value">To be added.</param>
        <summary>To be added.</summary>
        <returns>To be added.</returns>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="op_Implicit">
      <MemberSignature Language="C#" Value="public static System.Numerics.BigInteger op_Implicit (ulong value);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig specialname valuetype System.Numerics.BigInteger op_Implicit(unsigned int64 value) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName>System.CLSCompliant(false)</AttributeName>
        </Attribute>
      </Attributes>
      <ReturnValue>
        <ReturnType>System.Numerics.BigInteger</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.UInt64" />
      </Parameters>
      <Docs>
        <param name="value">To be added.</param>
        <summary>To be added.</summary>
        <returns>To be added.</returns>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="op_Increment">
      <MemberSignature Language="C#" Value="public static System.Numerics.BigInteger op_Increment (System.Numerics.BigInteger value);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig specialname valuetype System.Numerics.BigInteger op_Increment(valuetype System.Numerics.BigInteger value) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Numerics.BigInteger</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Numerics.BigInteger" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The <see cref="M:System.Numerics.BigInteger.op_Increment(System.Numerics.BigInteger)" /> method defines the increment operation for <see cref="T:System.Numerics.BigInteger" /> values. It enables code such as the following:</para>
          <para>code reference: System.Numeric.BigInteger.Class#24</para>
          <para>Some languages (such as Visual Basic) that lack an increment operator or do not support operator overloading can call the <see cref="M:System.Numerics.BigInteger.op_Increment(System.Numerics.BigInteger)" /> method directly, as the following example shows.</para>
          <para>code reference: System.Numeric.BigInteger.Class#25</para>
          <para>Because <see cref="T:System.Numerics.BigInteger" /> objects are immutable, the <see cref="M:System.Numerics.BigInteger.op_Increment(System.Numerics.BigInteger)" /> operator creates a new <see cref="T:System.Numerics.BigInteger" /> object whose value is one more than the <see cref="T:System.Numerics.BigInteger" /> object represented by <paramref name="value" />. Therefore, repeated calls to <see cref="M:System.Numerics.BigInteger.op_Increment(System.Numerics.BigInteger)" /> may be expensive.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Increments a <see cref="T:System.Numerics.BigInteger" /> value by 1.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The value of the <paramref name="value" /> parameter incremented by 1.</para>
        </returns>
        <param name="value">
          <attribution license="cc4" from="Microsoft" modified="false" />The value to increment.</param>
      </Docs>
    </Member>
    <Member MemberName="op_Inequality">
      <MemberSignature Language="C#" Value="public static bool op_Inequality (long left, System.Numerics.BigInteger right);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig specialname bool op_Inequality(int64 left, valuetype System.Numerics.BigInteger right) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="left" Type="System.Int64" />
        <Parameter Name="right" Type="System.Numerics.BigInteger" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The <see cref="M:System.Numerics.BigInteger.op_Inequality(System.Int64,System.Numerics.BigInteger)" /> method defines the operation of the inequality operator for <see cref="T:System.Numerics.BigInteger" /> values. It enables code such as the following:</para>
          <para>code reference: System.Numerics.BigInteger.Operators#25</para>
          <para>Languages that do not support custom operators can test for inequality by using one of the following techniques:</para>
          <list type="bullet">
            <item>
              <para>Calling the <see cref="M:System.Numerics.BigInteger.CompareTo(System.Int64)" /> instance method, which indicates the relationship between a <see cref="T:System.Numerics.BigInteger" /> and a signed long integer value.</para>
            </item>
            <item>
              <para>Calling the <see cref="M:System.Numerics.BigInteger.Equals(System.Int64)" /> instance method and reversing its value.</para>
            </item>
          </list>
          <para>If <paramref name="left" /> is a <see cref="T:System.Byte" />, <see cref="T:System.Int16" />, <see cref="T:System.Int32" />, <see cref="T:System.SByte" />, <see cref="T:System.UInt16" />, or <see cref="T:System.UInt32" /> value, it is implicitly converted to an <see cref="T:System.Int64" /> value when the operation is performed.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Returns a value that indicates whether a 64-bit signed integer and a <see cref="T:System.Numerics.BigInteger" /> value are not equal.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>true if <paramref name="left" /> and <paramref name="right" /> are not equal; otherwise, false.</para>
        </returns>
        <param name="left">
          <attribution license="cc4" from="Microsoft" modified="false" />The first value to compare.</param>
        <param name="right">
          <attribution license="cc4" from="Microsoft" modified="false" />The second value to compare.</param>
      </Docs>
    </Member>
    <Member MemberName="op_Inequality">
      <MemberSignature Language="C#" Value="public static bool op_Inequality (System.Numerics.BigInteger left, long right);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig specialname bool op_Inequality(valuetype System.Numerics.BigInteger left, int64 right) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="left" Type="System.Numerics.BigInteger" />
        <Parameter Name="right" Type="System.Int64" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The <see cref="M:System.Numerics.BigInteger.op_Inequality(System.Int64,System.Numerics.BigInteger)" /> method defines the operation of the inequality operator for <see cref="T:System.Numerics.BigInteger" /> values. It enables code such as the following:</para>
          <para>code reference: System.Numerics.BigInteger.Operators#26</para>
          <para>Languages that do not support custom operators can test for inequality by using one of the following techniques:</para>
          <list type="bullet">
            <item>
              <para>Calling the <see cref="M:System.Numerics.BigInteger.CompareTo(System.Int64)" /> method, which indicates the relationship between a <see cref="T:System.Numerics.BigInteger" /> and a signed long integer value.</para>
            </item>
            <item>
              <para>Calling the <see cref="M:System.Numerics.BigInteger.Equals(System.Int64)" /> method and reversing its value.</para>
            </item>
          </list>
          <para>If <paramref name="right" /> is a <see cref="T:System.Byte" />, <see cref="T:System.Int16" />, <see cref="T:System.Int32" />, <see cref="T:System.SByte" />, <see cref="T:System.UInt16" />, or <see cref="T:System.UInt32" /> value, it is implicitly converted to an <see cref="T:System.Int64" /> value when the operation is performed.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Returns a value that indicates whether a <see cref="T:System.Numerics.BigInteger" /> value and a 64-bit signed integer are not equal.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>true if <paramref name="left" /> and <paramref name="right" /> are not equal; otherwise, false.</para>
        </returns>
        <param name="left">
          <attribution license="cc4" from="Microsoft" modified="false" />The first value to compare.</param>
        <param name="right">
          <attribution license="cc4" from="Microsoft" modified="false" />The second value to compare.</param>
      </Docs>
    </Member>
    <Member MemberName="op_Inequality">
      <MemberSignature Language="C#" Value="public static bool op_Inequality (System.Numerics.BigInteger left, System.Numerics.BigInteger right);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig specialname bool op_Inequality(valuetype System.Numerics.BigInteger left, valuetype System.Numerics.BigInteger right) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="left" Type="System.Numerics.BigInteger" />
        <Parameter Name="right" Type="System.Numerics.BigInteger" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The <see cref="M:System.Numerics.BigInteger.op_Inequality(System.Int64,System.Numerics.BigInteger)" /> method defines the operation of the inequality operator for <see cref="T:System.Numerics.BigInteger" /> values. It enables code such as the following:</para>
          <para>code reference: System.Numeric.BigInteger.Class#26</para>
          <para>Languages that do not support custom operators can test for inequality by using one of the following techniques:</para>
          <list type="bullet">
            <item>
              <para>Calling the <see cref="M:System.Numerics.BigInteger.Compare(System.Numerics.BigInteger,System.Numerics.BigInteger)" /> method, which indicates the relationship between two <see cref="T:System.Numerics.BigInteger" /> objects. </para>
            </item>
            <item>
              <para>Calling the <see cref="M:System.Numerics.BigInteger.Equals(System.Numerics.BigInteger)" /> method and reversing its value.</para>
            </item>
          </list>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Returns a value that indicates whether two <see cref="T:System.Numerics.BigInteger" /> objects have different values.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>true if <paramref name="left" /> and <paramref name="right" /> are not equal; otherwise, false.</para>
        </returns>
        <param name="left">
          <attribution license="cc4" from="Microsoft" modified="false" />The first value to compare.</param>
        <param name="right">
          <attribution license="cc4" from="Microsoft" modified="false" />The second value to compare.</param>
      </Docs>
    </Member>
    <Member MemberName="op_Inequality">
      <MemberSignature Language="C#" Value="public static bool op_Inequality (System.Numerics.BigInteger left, ulong right);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig specialname bool op_Inequality(valuetype System.Numerics.BigInteger left, unsigned int64 right) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName>System.CLSCompliant(false)</AttributeName>
        </Attribute>
      </Attributes>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="left" Type="System.Numerics.BigInteger" />
        <Parameter Name="right" Type="System.UInt64" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The <see cref="M:System.Numerics.BigInteger.op_Inequality(System.Int64,System.Numerics.BigInteger)" /> method defines the operation of the inequality operator for <see cref="T:System.Numerics.BigInteger" /> values. It enables code such as the following:</para>
          <para>code reference: System.Numerics.BigInteger.Operators#27</para>
          <para>Languages that do not support custom operators can test for inequality by using one of the following techniques:</para>
          <list type="bullet">
            <item>
              <para>Calling the <see cref="M:System.Numerics.BigInteger.CompareTo(System.UInt64)" /> method, which indicates the relationship between a <see cref="T:System.Numerics.BigInteger" /> and an unsigned long integer value.</para>
            </item>
            <item>
              <para>Calling the <see cref="M:System.Numerics.BigInteger.Equals(System.UInt64)" /> method and reversing its value.</para>
            </item>
          </list>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Returns a value that indicates whether a <see cref="T:System.Numerics.BigInteger" /> value and a 64-bit unsigned integer are not equal.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>true if <paramref name="left" /> and <paramref name="right" /> are not equal; otherwise, false.</para>
        </returns>
        <param name="left">
          <attribution license="cc4" from="Microsoft" modified="false" />The first value to compare.</param>
        <param name="right">
          <attribution license="cc4" from="Microsoft" modified="false" />The second value to compare.</param>
      </Docs>
    </Member>
    <Member MemberName="op_Inequality">
      <MemberSignature Language="C#" Value="public static bool op_Inequality (ulong left, System.Numerics.BigInteger right);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig specialname bool op_Inequality(unsigned int64 left, valuetype System.Numerics.BigInteger right) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName>System.CLSCompliant(false)</AttributeName>
        </Attribute>
      </Attributes>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="left" Type="System.UInt64" />
        <Parameter Name="right" Type="System.Numerics.BigInteger" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The <see cref="M:System.Numerics.BigInteger.op_Inequality(System.Int64,System.Numerics.BigInteger)" /> method defines the operation of the inequality operator for <see cref="T:System.Numerics.BigInteger" /> values. It enables code such as the following:</para>
          <para>code reference: System.Numerics.BigInteger.Operators#28</para>
          <para>Languages that do not support custom operators can test for inequality by using one of the following techniques:</para>
          <list type="bullet">
            <item>
              <para>Calling the <see cref="M:System.Numerics.BigInteger.CompareTo(System.UInt64)" /> method, which indicates the relationship between a <see cref="T:System.Numerics.BigInteger" /> and an unsigned long integer value.</para>
            </item>
            <item>
              <para>Calling the <see cref="M:System.Numerics.BigInteger.Equals(System.UInt64)" /> method and reversing its value.</para>
            </item>
          </list>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Returns a value that indicates whether a 64-bit unsigned integer and a <see cref="T:System.Numerics.BigInteger" /> value are not equal.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>true if <paramref name="left" /> and <paramref name="right" /> are not equal; otherwise, false.</para>
        </returns>
        <param name="left">
          <attribution license="cc4" from="Microsoft" modified="false" />The first value to compare.</param>
        <param name="right">
          <attribution license="cc4" from="Microsoft" modified="false" />The second value to compare.</param>
      </Docs>
    </Member>
    <Member MemberName="op_LeftShift">
      <MemberSignature Language="C#" Value="public static System.Numerics.BigInteger op_LeftShift (System.Numerics.BigInteger value, int shift);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig specialname valuetype System.Numerics.BigInteger op_LeftShift(valuetype System.Numerics.BigInteger value, int32 shift) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Numerics.BigInteger</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Numerics.BigInteger" />
        <Parameter Name="shift" Type="System.Int32" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The <see cref="M:System.Numerics.BigInteger.op_LeftShift(System.Numerics.BigInteger,System.Int32)" /> method defines the operation of the bitwise left-shift operator for <see cref="T:System.Numerics.BigInteger" /> values. It enables code such as the following:</para>
          <para>code reference: System.Numerics.BigInteger.Operators#29</para>
          <block subset="none" type="note">
            <para>Unlike the bitwise left-shift operation with integer primitives, the <see cref="M:System.Numerics.BigInteger.op_LeftShift(System.Numerics.BigInteger,System.Int32)" /> method preserves the sign of the original <see cref="T:System.Numerics.BigInteger" /> value.</para>
          </block>
          <para>Languages that do not support custom operators can perform a bitwise left-shift operation by multiplying <paramref name="value" /> by BigInteger.Pow(2, <paramref name="shift" />). The following example shows that the results are identical to the results of using this operator.</para>
          <para>code reference: System.Numerics.BigInteger.Operators#30</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Shifts a <see cref="T:System.Numerics.BigInteger" /> value a specified number of bits to the left.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>A value that has been shifted to the left by the specified number of bits.</para>
        </returns>
        <param name="value">
          <attribution license="cc4" from="Microsoft" modified="false" />The value whose bits are to be shifted.</param>
        <param name="shift">
          <attribution license="cc4" from="Microsoft" modified="false" />The number of bits to shift <paramref name="value" /> to the left.</param>
      </Docs>
    </Member>
    <Member MemberName="op_LessThan">
      <MemberSignature Language="C#" Value="public static bool op_LessThan (long left, System.Numerics.BigInteger right);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig specialname bool op_LessThan(int64 left, valuetype System.Numerics.BigInteger right) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="left" Type="System.Int64" />
        <Parameter Name="right" Type="System.Numerics.BigInteger" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The <see cref="M:System.Numerics.BigInteger.op_LessThan(System.Int64,System.Numerics.BigInteger)" /> method defines the operation of the less than operator for <see cref="T:System.Numerics.BigInteger" /> values. It enables code such as the following:</para>
          <para>code reference: System.Numerics.BigInteger.Operators#31</para>
          <para>Languages that do not support custom operators can call the <see cref="M:System.Numerics.BigInteger.CompareTo(System.Int64)" /> method instead. Some languages can also call the <see cref="M:System.Numerics.BigInteger.op_LessThan(System.Int64,System.Numerics.BigInteger)" /> method directly, as the following example shows.</para>
          <para>code reference: System.Numerics.BigInteger.Operators#32</para>
          <para>If <paramref name="left" /> is a <see cref="T:System.Byte" />, <see cref="T:System.Int16" />, <see cref="T:System.Int32" />, <see cref="T:System.SByte" />, <see cref="T:System.UInt16" />, or <see cref="T:System.UInt32" /> value, it is implicitly converted to an <see cref="T:System.Int64" /> value when the operation is performed.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Returns a value that indicates whether a 64-bit signed integer is less than a <see cref="T:System.Numerics.BigInteger" /> value.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>true if <paramref name="left" /> is less than <paramref name="right" />; otherwise, false.</para>
        </returns>
        <param name="left">
          <attribution license="cc4" from="Microsoft" modified="false" />The first value to compare.</param>
        <param name="right">
          <attribution license="cc4" from="Microsoft" modified="false" />The second value to compare.</param>
      </Docs>
    </Member>
    <Member MemberName="op_LessThan">
      <MemberSignature Language="C#" Value="public static bool op_LessThan (System.Numerics.BigInteger left, long right);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig specialname bool op_LessThan(valuetype System.Numerics.BigInteger left, int64 right) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="left" Type="System.Numerics.BigInteger" />
        <Parameter Name="right" Type="System.Int64" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The <see cref="M:System.Numerics.BigInteger.op_LessThan(System.Int64,System.Numerics.BigInteger)" /> method defines the operation of the less than operator for <see cref="T:System.Numerics.BigInteger" /> values. It enables code such as the following:</para>
          <para>code reference: System.Numerics.BigInteger.Operators#33</para>
          <para>Languages that do not support custom operators can call the <see cref="M:System.Numerics.BigInteger.CompareTo(System.Int64)" /> method instead. Some languages can also call the <see cref="M:System.Numerics.BigInteger.op_LessThan(System.Numerics.BigInteger,System.Int64)" /> method directly, as the following example shows.</para>
          <para>code reference: System.Numerics.BigInteger.Operators#34</para>
          <para>If <paramref name="right" /> is a <see cref="T:System.Byte" />, <see cref="T:System.Int16" />, <see cref="T:System.Int32" />, <see cref="T:System.SByte" />, <see cref="T:System.UInt16" />, or <see cref="T:System.UInt32" /> value, it is implicitly converted to an <see cref="T:System.Int64" /> value when the operation is performed.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Returns a value that indicates whether a <see cref="T:System.Numerics.BigInteger" /> value is less than a 64-bit signed integer.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>true if <paramref name="left" /> is less than <paramref name="right" />; otherwise, false.</para>
        </returns>
        <param name="left">
          <attribution license="cc4" from="Microsoft" modified="false" />The first value to compare.</param>
        <param name="right">
          <attribution license="cc4" from="Microsoft" modified="false" />The second value to compare.</param>
      </Docs>
    </Member>
    <Member MemberName="op_LessThan">
      <MemberSignature Language="C#" Value="public static bool op_LessThan (System.Numerics.BigInteger left, System.Numerics.BigInteger right);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig specialname bool op_LessThan(valuetype System.Numerics.BigInteger left, valuetype System.Numerics.BigInteger right) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="left" Type="System.Numerics.BigInteger" />
        <Parameter Name="right" Type="System.Numerics.BigInteger" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The <see cref="M:System.Numerics.BigInteger.op_LessThan(System.Int64,System.Numerics.BigInteger)" /> method defines the operation of the less than operator for <see cref="T:System.Numerics.BigInteger" /> values. It enables code such as the following:</para>
          <para>code reference: System.Numeric.BigInteger.Class#27</para>
          <para>Languages that do not support custom operators can call the <see cref="M:System.Numerics.BigInteger.Compare(System.Numerics.BigInteger,System.Numerics.BigInteger)" /> method instead. Some languages can also call the <see cref="M:System.Numerics.BigInteger.op_LessThan(System.Numerics.BigInteger,System.Numerics.BigInteger)" /> method directly, as the following example shows.</para>
          <para>code reference: System.Numeric.BigInteger.Class#28</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Returns a value that indicates whether a <see cref="T:System.Numerics.BigInteger" /> value is less than another <see cref="T:System.Numerics.BigInteger" /> value.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>true if <paramref name="left" /> is less than <paramref name="right" />; otherwise, false.</para>
        </returns>
        <param name="left">
          <attribution license="cc4" from="Microsoft" modified="false" />The first value to compare.</param>
        <param name="right">
          <attribution license="cc4" from="Microsoft" modified="false" />The second value to compare.</param>
      </Docs>
    </Member>
    <Member MemberName="op_LessThan">
      <MemberSignature Language="C#" Value="public static bool op_LessThan (System.Numerics.BigInteger left, ulong right);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig specialname bool op_LessThan(valuetype System.Numerics.BigInteger left, unsigned int64 right) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName>System.CLSCompliant(false)</AttributeName>
        </Attribute>
      </Attributes>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="left" Type="System.Numerics.BigInteger" />
        <Parameter Name="right" Type="System.UInt64" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The <see cref="M:System.Numerics.BigInteger.op_LessThan(System.Int64,System.Numerics.BigInteger)" /> method defines the operation of the less than operator for <see cref="T:System.Numerics.BigInteger" /> values. It enables code such as the following:</para>
          <para>code reference: System.Numerics.BigInteger.Operators#35</para>
          <para>Languages that do not support custom operators can call the <see cref="M:System.Numerics.BigInteger.CompareTo(System.UInt64)" /> method instead. They can also call the <see cref="M:System.Numerics.BigInteger.op_LessThan(System.Numerics.BigInteger,System.UInt64)" /> method directly, as the following example shows.</para>
          <para>code reference: System.Numerics.BigInteger.Operators#36</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Returns a value that indicates whether a <see cref="T:System.Numerics.BigInteger" /> value is less than a 64-bit unsigned integer.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>true if <paramref name="left" /> is less than <paramref name="right" />; otherwise, false.</para>
        </returns>
        <param name="left">
          <attribution license="cc4" from="Microsoft" modified="false" />The first value to compare.</param>
        <param name="right">
          <attribution license="cc4" from="Microsoft" modified="false" />The second value to compare.</param>
      </Docs>
    </Member>
    <Member MemberName="op_LessThan">
      <MemberSignature Language="C#" Value="public static bool op_LessThan (ulong left, System.Numerics.BigInteger right);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig specialname bool op_LessThan(unsigned int64 left, valuetype System.Numerics.BigInteger right) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName>System.CLSCompliant(false)</AttributeName>
        </Attribute>
      </Attributes>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="left" Type="System.UInt64" />
        <Parameter Name="right" Type="System.Numerics.BigInteger" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The <see cref="M:System.Numerics.BigInteger.op_LessThan(System.Int64,System.Numerics.BigInteger)" /> method defines the operation of the less than operator for <see cref="T:System.Numerics.BigInteger" /> values. It enables code such as the following:</para>
          <para>code reference: System.Numerics.BigInteger.Operators#37</para>
          <para>Languages that do not support custom operators can call the <see cref="M:System.Numerics.BigInteger.CompareTo(System.UInt64)" /> method instead. They can also call the <see cref="M:System.Numerics.BigInteger.op_LessThan(System.UInt64,System.Numerics.BigInteger)" /> method directly, as the following example shows.</para>
          <para>code reference: System.Numerics.BigInteger.Operators#38</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Returns a value that indicates whether a 64-bit unsigned integer is less than a <see cref="T:System.Numerics.BigInteger" /> value.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>true if <paramref name="left" /> is less than <paramref name="right" />; otherwise, false.</para>
        </returns>
        <param name="left">
          <attribution license="cc4" from="Microsoft" modified="false" />The first value to compare.</param>
        <param name="right">
          <attribution license="cc4" from="Microsoft" modified="false" />The second value to compare.</param>
      </Docs>
    </Member>
    <Member MemberName="op_LessThanOrEqual">
      <MemberSignature Language="C#" Value="public static bool op_LessThanOrEqual (long left, System.Numerics.BigInteger right);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig specialname bool op_LessThanOrEqual(int64 left, valuetype System.Numerics.BigInteger right) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="left" Type="System.Int64" />
        <Parameter Name="right" Type="System.Numerics.BigInteger" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The <see cref="M:System.Numerics.BigInteger.op_LessThanOrEqual(System.Int64,System.Numerics.BigInteger)" /> method defines the operation of the less than or equal to operator for <see cref="T:System.Numerics.BigInteger" /> values. It enables code such as the following:</para>
          <para>code reference: System.Numerics.BigInteger.Operators#39</para>
          <para>Languages that do not support custom operators can call the <see cref="M:System.Numerics.BigInteger.CompareTo(System.Int64)" /> method instead. They can also call the <see cref="M:System.Numerics.BigInteger.op_LessThanOrEqual(System.Int64,System.Numerics.BigInteger)" /> method directly, as the following example shows.</para>
          <para>code reference: System.Numerics.BigInteger.Operators#40</para>
          <para>If <paramref name="left" /> is a <see cref="T:System.Byte" />, <see cref="T:System.Int16" />, <see cref="T:System.Int32" />, <see cref="T:System.SByte" />, <see cref="T:System.UInt16" />, or <see cref="T:System.UInt32" /> value, it is implicitly converted to an <see cref="T:System.Int64" /> value when the operation is performed.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Returns a value that indicates whether a 64-bit signed integer is less than or equal to a <see cref="T:System.Numerics.BigInteger" /> value.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>true if <paramref name="left" /> is less than or equal to <paramref name="right" />; otherwise, false.</para>
        </returns>
        <param name="left">
          <attribution license="cc4" from="Microsoft" modified="false" />The first value to compare.</param>
        <param name="right">
          <attribution license="cc4" from="Microsoft" modified="false" />The second value to compare.</param>
      </Docs>
    </Member>
    <Member MemberName="op_LessThanOrEqual">
      <MemberSignature Language="C#" Value="public static bool op_LessThanOrEqual (System.Numerics.BigInteger left, long right);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig specialname bool op_LessThanOrEqual(valuetype System.Numerics.BigInteger left, int64 right) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="left" Type="System.Numerics.BigInteger" />
        <Parameter Name="right" Type="System.Int64" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The <see cref="M:System.Numerics.BigInteger.op_LessThanOrEqual(System.Int64,System.Numerics.BigInteger)" /> method defines the operation of the less than or equal to operator for <see cref="T:System.Numerics.BigInteger" /> values. It enables code such as the following:</para>
          <para>code reference: System.Numerics.BigInteger.Operators#41</para>
          <para>Languages that do not support custom operators can call the <see cref="M:System.Numerics.BigInteger.CompareTo(System.Int64)" /> method instead. They can also call the <see cref="M:System.Numerics.BigInteger.op_LessThanOrEqual(System.Numerics.BigInteger,System.Int64)" /> method directly, as the following example shows.</para>
          <para>code reference: System.Numerics.BigInteger.Operators#42</para>
          <para>If <paramref name="right" /> is a <see cref="T:System.Byte" />, <see cref="T:System.Int16" />, <see cref="T:System.Int32" />, <see cref="T:System.SByte" />, <see cref="T:System.UInt16" />, or <see cref="T:System.UInt32" /> value, it is implicitly converted to an <see cref="T:System.Int64" /> value when the operation is performed.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Returns a value that indicates whether a <see cref="T:System.Numerics.BigInteger" /> value is less than or equal to a 64-bit signed integer.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>true if <paramref name="left" /> is less than or equal to <paramref name="right" />; otherwise, false.</para>
        </returns>
        <param name="left">
          <attribution license="cc4" from="Microsoft" modified="false" />The first value to compare.</param>
        <param name="right">
          <attribution license="cc4" from="Microsoft" modified="false" />The second value to compare.</param>
      </Docs>
    </Member>
    <Member MemberName="op_LessThanOrEqual">
      <MemberSignature Language="C#" Value="public static bool op_LessThanOrEqual (System.Numerics.BigInteger left, System.Numerics.BigInteger right);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig specialname bool op_LessThanOrEqual(valuetype System.Numerics.BigInteger left, valuetype System.Numerics.BigInteger right) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="left" Type="System.Numerics.BigInteger" />
        <Parameter Name="right" Type="System.Numerics.BigInteger" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The <see cref="M:System.Numerics.BigInteger.op_LessThanOrEqual(System.Int64,System.Numerics.BigInteger)" /> method defines the operation of the less than or equal to operator for <see cref="T:System.Numerics.BigInteger" /> values. It enables code such as the following:</para>
          <para>code reference: System.Numeric.BigInteger.Class#29</para>
          <para>Languages that do not support custom operators can call the <see cref="M:System.Numerics.BigInteger.Compare(System.Numerics.BigInteger,System.Numerics.BigInteger)" /> method instead. They can also call the <see cref="M:System.Numerics.BigInteger.op_LessThanOrEqual(System.Numerics.BigInteger,System.Numerics.BigInteger)" /> method directly, as the following example shows.</para>
          <para>code reference: System.Numeric.BigInteger.Class#30</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Returns a value that indicates whether a <see cref="T:System.Numerics.BigInteger" /> value is less than or equal to another <see cref="T:System.Numerics.BigInteger" /> value.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>true if <paramref name="left" /> is less than or equal to <paramref name="right" />; otherwise, false.</para>
        </returns>
        <param name="left">
          <attribution license="cc4" from="Microsoft" modified="false" />The first value to compare.</param>
        <param name="right">
          <attribution license="cc4" from="Microsoft" modified="false" />The second value to compare.</param>
      </Docs>
    </Member>
    <Member MemberName="op_LessThanOrEqual">
      <MemberSignature Language="C#" Value="public static bool op_LessThanOrEqual (System.Numerics.BigInteger left, ulong right);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig specialname bool op_LessThanOrEqual(valuetype System.Numerics.BigInteger left, unsigned int64 right) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName>System.CLSCompliant(false)</AttributeName>
        </Attribute>
      </Attributes>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="left" Type="System.Numerics.BigInteger" />
        <Parameter Name="right" Type="System.UInt64" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The <see cref="M:System.Numerics.BigInteger.op_LessThanOrEqual(System.Int64,System.Numerics.BigInteger)" /> method defines the operation of the less than or equal to operator for <see cref="T:System.Numerics.BigInteger" /> values. It enables code such as the following:</para>
          <para>code reference: System.Numerics.BigInteger.Operators#43</para>
          <para>Languages that do not support custom operators can call the <see cref="M:System.Numerics.BigInteger.CompareTo(System.UInt64)" /> method instead. They can also call the <see cref="M:System.Numerics.BigInteger.op_LessThanOrEqual(System.Numerics.BigInteger,System.UInt64)" /> method directly, as the following example shows.</para>
          <para>code reference: System.Numerics.BigInteger.Operators#44</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Returns a value that indicates whether a <see cref="T:System.Numerics.BigInteger" /> value is less than or equal to a 64-bit unsigned integer.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>true if <paramref name="left" /> is less than or equal to <paramref name="right" />; otherwise, false.</para>
        </returns>
        <param name="left">
          <attribution license="cc4" from="Microsoft" modified="false" />The first value to compare.</param>
        <param name="right">
          <attribution license="cc4" from="Microsoft" modified="false" />The second value to compare.</param>
      </Docs>
    </Member>
    <Member MemberName="op_LessThanOrEqual">
      <MemberSignature Language="C#" Value="public static bool op_LessThanOrEqual (ulong left, System.Numerics.BigInteger right);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig specialname bool op_LessThanOrEqual(unsigned int64 left, valuetype System.Numerics.BigInteger right) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <Attributes>
        <Attribute>
          <AttributeName>System.CLSCompliant(false)</AttributeName>
        </Attribute>
      </Attributes>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="left" Type="System.UInt64" />
        <Parameter Name="right" Type="System.Numerics.BigInteger" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The <see cref="M:System.Numerics.BigInteger.op_LessThanOrEqual(System.Int64,System.Numerics.BigInteger)" /> method defines the operation of the less than or equal to operator for <see cref="T:System.Numerics.BigInteger" /> values. It enables code such as the following:</para>
          <para>code reference: System.Numerics.BigInteger.Operators#45</para>
          <para>Languages that do not support custom operators can call the <see cref="M:System.Numerics.BigInteger.CompareTo(System.UInt64)" /> method instead. They can also call the <see cref="M:System.Numerics.BigInteger.op_LessThanOrEqual(System.UInt64,System.Numerics.BigInteger)" /> method directly, as the following example shows.</para>
          <para>code reference: System.Numerics.BigInteger.Operators#46</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Returns a value that indicates whether a 64-bit unsigned integer is less than or equal to a <see cref="T:System.Numerics.BigInteger" /> value.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>true if <paramref name="left" /> is less than or equal to <paramref name="right" />; otherwise, false.</para>
        </returns>
        <param name="left">
          <attribution license="cc4" from="Microsoft" modified="false" />The first value to compare.</param>
        <param name="right">
          <attribution license="cc4" from="Microsoft" modified="false" />The second value to compare.</param>
      </Docs>
    </Member>
    <Member MemberName="op_Modulus">
      <MemberSignature Language="C#" Value="public static System.Numerics.BigInteger op_Modulus (System.Numerics.BigInteger dividend, System.Numerics.BigInteger divisor);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig specialname valuetype System.Numerics.BigInteger op_Modulus(valuetype System.Numerics.BigInteger dividend, valuetype System.Numerics.BigInteger divisor) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Numerics.BigInteger</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="dividend" Type="System.Numerics.BigInteger" />
        <Parameter Name="divisor" Type="System.Numerics.BigInteger" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The <see cref="M:System.Numerics.BigInteger.op_Modulus(System.Numerics.BigInteger,System.Numerics.BigInteger)" /> method defines the operation of the modulus operator for <see cref="T:System.Numerics.BigInteger" /> values. It enables code such as the following:</para>
          <para>code reference: System.Numeric.BigInteger.Class#31</para>
          <para>Languages that do not support custom operators can call the <see cref="M:System.Numerics.BigInteger.Remainder(System.Numerics.BigInteger,System.Numerics.BigInteger)" /> method instead.</para>
          <para>The sign of the value returned by the modulus operation depends on the sign of <paramref name="dividend" />: If <paramref name="dividend" /> is positive, the modulus operation returns a positive result; if it is negative, the modulus operation returns a negative result. The behavior of the modulus operation with <see cref="T:System.Numerics.BigInteger" /> values is identical to the modulus operation with other integral types.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Returns the remainder that results from division with two specified <see cref="T:System.Numerics.BigInteger" /> values.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The remainder that results from the division.</para>
        </returns>
        <param name="dividend">
          <attribution license="cc4" from="Microsoft" modified="false" />The value to be divided.</param>
        <param name="divisor">
          <attribution license="cc4" from="Microsoft" modified="false" />The value to divide by.</param>
      </Docs>
    </Member>
    <Member MemberName="op_Multiply">
      <MemberSignature Language="C#" Value="public static System.Numerics.BigInteger op_Multiply (System.Numerics.BigInteger left, System.Numerics.BigInteger right);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig specialname valuetype System.Numerics.BigInteger op_Multiply(valuetype System.Numerics.BigInteger left, valuetype System.Numerics.BigInteger right) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Numerics.BigInteger</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="left" Type="System.Numerics.BigInteger" />
        <Parameter Name="right" Type="System.Numerics.BigInteger" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The <see cref="M:System.Numerics.BigInteger.op_Multiply(System.Numerics.BigInteger,System.Numerics.BigInteger)" /> method defines the operation of the multiplication operator for <see cref="T:System.Numerics.BigInteger" /> values. It enables code such as the following:</para>
          <para>code reference: System.Numeric.BigInteger.Class#11</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Multiplies two specified <see cref="T:System.Numerics.BigInteger" /> values.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The product of <paramref name="left" /> and <paramref name="right" />.</para>
        </returns>
        <param name="left">
          <attribution license="cc4" from="Microsoft" modified="false" />The first value to multiply.</param>
        <param name="right">
          <attribution license="cc4" from="Microsoft" modified="false" />The second value to multiply.</param>
      </Docs>
    </Member>
    <Member MemberName="op_OnesComplement">
      <MemberSignature Language="C#" Value="public static System.Numerics.BigInteger op_OnesComplement (System.Numerics.BigInteger value);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig specialname valuetype System.Numerics.BigInteger op_OnesComplement(valuetype System.Numerics.BigInteger value) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Numerics.BigInteger</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Numerics.BigInteger" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The <see cref="M:System.Numerics.BigInteger.op_OnesComplement(System.Numerics.BigInteger)" /> method defines the operation of the bitwise one's complement operator for <see cref="T:System.Numerics.BigInteger" /> values. The bitwise one's complement operator reverses each bit in a numeric value. That is, bits in <paramref name="value" /> that are 0 are set to 1 in the result, and bits that are 1 are set to 0 in the result. The <see cref="M:System.Numerics.BigInteger.op_OnesComplement(System.Numerics.BigInteger)" /> method enables code such as the following:</para>
          <para>code reference: System.Numerics.BigInteger.OnesComplement#1</para>
          <para>Languages that do not support custom operators may be able to call the <see cref="M:System.Numerics.BigInteger.op_OnesComplement(System.Numerics.BigInteger)" /> method directly to perform a bitwise one's complement operation. For example:</para>
          <para>code reference: System.Numerics.BigInteger.OnesComplement#2</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Returns the bitwise one's complement of a <see cref="T:System.Numerics.BigInteger" /> value.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The bitwise one's complement of <paramref name="value" />.</para>
        </returns>
        <param name="value">
          <attribution license="cc4" from="Microsoft" modified="false" />An integer value.</param>
      </Docs>
    </Member>
    <Member MemberName="op_RightShift">
      <MemberSignature Language="C#" Value="public static System.Numerics.BigInteger op_RightShift (System.Numerics.BigInteger value, int shift);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig specialname valuetype System.Numerics.BigInteger op_RightShift(valuetype System.Numerics.BigInteger value, int32 shift) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Numerics.BigInteger</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Numerics.BigInteger" />
        <Parameter Name="shift" Type="System.Int32" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The <see cref="M:System.Numerics.BigInteger.op_RightShift(System.Numerics.BigInteger,System.Int32)" /> method defines the operation of the bitwise right-shift operator for <see cref="T:System.Numerics.BigInteger" /> values. It enables code such as the following:</para>
          <para>code reference: System.Numeric.BigInteger.Operators#47</para>
          <para>Languages that do not support custom operators can perform a bitwise right-shift operation by dividing <paramref name="value" /> by BigInteger.Pow(2, <paramref name="shift" />) and subtracting 1 times <paramref name="shift" /> for negative values. The following example shows that the results are identical to the results of using this operator.</para>
          <para>code reference: System.Numerics.BigInteger.Operators#48</para>
          <para>If <paramref name="shift" /> is greater than or equal to the number of bits in a positive <see cref="T:System.Numerics.BigInteger" /> value, the result of the right-shift operation is <see cref="P:System.Numerics.BigInteger.Zero" />. If <paramref name="shift" /> is greater than the number of bits in a negative <see cref="T:System.Numerics.BigInteger" /> value, the result of the right-shift operation is <see cref="P:System.Numerics.BigInteger.MinusOne" />.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Shifts a <see cref="T:System.Numerics.BigInteger" /> value a specified number of bits to the right.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>A value that has been shifted to the right by the specified number of bits.</para>
        </returns>
        <param name="value">
          <attribution license="cc4" from="Microsoft" modified="false" />The value whose bits are to be shifted.</param>
        <param name="shift">
          <attribution license="cc4" from="Microsoft" modified="false" />The number of bits to shift <paramref name="value" /> to the right.</param>
      </Docs>
    </Member>
    <Member MemberName="op_Subtraction">
      <MemberSignature Language="C#" Value="public static System.Numerics.BigInteger op_Subtraction (System.Numerics.BigInteger left, System.Numerics.BigInteger right);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig specialname valuetype System.Numerics.BigInteger op_Subtraction(valuetype System.Numerics.BigInteger left, valuetype System.Numerics.BigInteger right) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Numerics.BigInteger</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="left" Type="System.Numerics.BigInteger" />
        <Parameter Name="right" Type="System.Numerics.BigInteger" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The <see cref="M:System.Numerics.BigInteger.op_Subtraction(System.Numerics.BigInteger,System.Numerics.BigInteger)" /> method defines the operation of the subtraction operator for <see cref="T:System.Numerics.BigInteger" /> values. It enables code such as the following:</para>
          <para>code reference: System.Numeric.BigInteger.Class#14</para>
          <para>Languages that do not support custom operators can call the <see cref="M:System.Numerics.BigInteger.Subtract(System.Numerics.BigInteger,System.Numerics.BigInteger)" /> method instead.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Subtracts a <see cref="T:System.Numerics.BigInteger" /> value from another <see cref="T:System.Numerics.BigInteger" /> value.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The result of subtracting <paramref name="right" /> from <paramref name="left" />.</para>
        </returns>
        <param name="left">
          <attribution license="cc4" from="Microsoft" modified="false" />The value to subtract from (the minuend).</param>
        <param name="right">
          <attribution license="cc4" from="Microsoft" modified="false" />The value to subtract (the subtrahend).</param>
      </Docs>
    </Member>
    <Member MemberName="op_UnaryNegation">
      <MemberSignature Language="C#" Value="public static System.Numerics.BigInteger op_UnaryNegation (System.Numerics.BigInteger value);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig specialname valuetype System.Numerics.BigInteger op_UnaryNegation(valuetype System.Numerics.BigInteger value) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Numerics.BigInteger</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Numerics.BigInteger" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The <see cref="M:System.Numerics.BigInteger.op_UnaryNegation(System.Numerics.BigInteger)" /> method defines the operation of the unary negation operator (or the additive inverse operator) for <see cref="T:System.Numerics.BigInteger" /> values. The operation produces a value that results in 0 (zero) when it is added to the original number. Languages that do not support custom operators can call the <see cref="M:System.Numerics.BigInteger.Negate(System.Numerics.BigInteger)" /> method instead.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Negates a specified BigInteger value. </para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The result of the <paramref name="value" /> parameter multiplied by negative one (-1).</para>
        </returns>
        <param name="value">
          <attribution license="cc4" from="Microsoft" modified="false" />The value to negate.</param>
      </Docs>
    </Member>
    <Member MemberName="op_UnaryPlus">
      <MemberSignature Language="C#" Value="public static System.Numerics.BigInteger op_UnaryPlus (System.Numerics.BigInteger value);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig specialname valuetype System.Numerics.BigInteger op_UnaryPlus(valuetype System.Numerics.BigInteger value) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Numerics.BigInteger</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Numerics.BigInteger" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The <see cref="M:System.Numerics.BigInteger.op_UnaryPlus(System.Numerics.BigInteger)" /> method defines the operation of the unary positive operator for <see cref="T:System.Numerics.BigInteger" /> values.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Returns the value of the <see cref="T:System.Numerics.BigInteger" /> operand. (The sign of the operand is unchanged.)</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The value of the <paramref name="value" /> operand.</para>
        </returns>
        <param name="value">
          <attribution license="cc4" from="Microsoft" modified="false" />An integer value.</param>
      </Docs>
    </Member>
    <Member MemberName="Parse">
      <MemberSignature Language="C#" Value="public static System.Numerics.BigInteger Parse (string value);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig valuetype System.Numerics.BigInteger Parse(string value) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Numerics.BigInteger</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.String" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The <paramref name="value" /> parameter should be the string representation of a number in the following 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>
              <item>
                <term>
                  <para>Element</para>
                </term>
                <description>
                  <para>Description</para>
                </description>
              </item>
            </listheader>
            <item>
              <term>
                <para>ws</para>
              </term>
              <description>
                <para>Optional white space.</para>
              </description>
            </item>
            <item>
              <term>
                <para>sign</para>
              </term>
              <description>
                <para>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.</para>
              </description>
            </item>
            <item>
              <term>
                <para>digits</para>
              </term>
              <description>
                <para>A sequence of digits ranging from 0 to 9. Any leading zeros are ignored.</para>
              </description>
            </item>
          </list>
          <block subset="none" type="note">
            <para>The string specified by the <paramref name="value" /> parameter is interpreted by 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.</para>
          </block>
          <para>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:System.Numerics.BigInteger.Parse(System.String,System.IFormatProvider)" /> method.</para>
          <block subset="none" type="note">
            <para>If you use the <see cref="M:System.Numerics.BigInteger.Parse(System.String)" /> method to round-trip the string representation of a <see cref="T:System.Numerics.BigInteger" /> value that was output by the <see cref="Overload:System.Numerics.BigInteger.ToString" /> method, you should use the <see cref="M:System.Numerics.BigInteger.ToString(System.String)" /> method with the "R" format specifier to generate the string representation of the <see cref="T:System.Numerics.BigInteger" /> value. Otherwise, the string representation of the <see cref="T:System.Numerics.BigInteger" /> preserves only the 50 most significant digits of the original value, and data may be lost when you use the <see cref="M:System.Numerics.BigInteger.Parse(System.String)" /> method to restore the <see cref="T:System.Numerics.BigInteger" /> value.</para>
          </block>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Converts the string representation of a number to its <see cref="T:System.Numerics.BigInteger" /> equivalent.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>A value that is equivalent to the number specified in the <paramref name="value" /> parameter.</para>
        </returns>
        <param name="value">
          <attribution license="cc4" from="Microsoft" modified="false" />A string that contains the number to convert.</param>
      </Docs>
    </Member>
    <Member MemberName="Parse">
      <MemberSignature Language="C#" Value="public static System.Numerics.BigInteger Parse (string value, System.Globalization.NumberStyles style);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig valuetype System.Numerics.BigInteger Parse(string value, valuetype System.Globalization.NumberStyles style) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Numerics.BigInteger</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.String" />
        <Parameter Name="style" Type="System.Globalization.NumberStyles" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>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="styles" /> 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 <paramref name="value" /> is known only at run time, or when you want to disallow white space or a sign symbol in <paramref name="value" />.</para>
          <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 contain 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>
              <item>
                <term>
                  <para>Element</para>
                </term>
                <description>
                  <para>Description</para>
                </description>
              </item>
            </listheader>
            <item>
              <term>
                <para>ws</para>
              </term>
              <description>
                <para>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="value" /> if <paramref name="style" /> includes the <see cref="F:System.Globalization.NumberStyles.AllowTrailingWhite" /> flag.</para>
              </description>
            </item>
            <item>
              <term>
                <para>$</para>
              </term>
              <description>
                <para>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.</para>
              </description>
            </item>
            <item>
              <term>
                <para>sign</para>
              </term>
              <description>
                <para>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. </para>
              </description>
            </item>
            <item>
              <term>
                <para>digits</para>
                <para>fractional_digits</para>
                <para>exponential_digits</para>
              </term>
              <description>
                <para>A sequence of digits from 0 through 9. For fractional_digits, only the digit 0 is valid.</para>
              </description>
            </item>
            <item>
              <term>
                <para>,</para>
              </term>
              <description>
                <para>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.</para>
              </description>
            </item>
            <item>
              <term>
                <para>.</para>
              </term>
              <description>
                <para>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. 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.</para>
              </description>
            </item>
            <item>
              <term>
                <para>E</para>
              </term>
              <description>
                <para>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.</para>
              </description>
            </item>
            <item>
              <term>
                <para>hexdigits</para>
              </term>
              <description>
                <para>A sequence of hexadecimal digits from 0 through f, or 0 through F. </para>
              </description>
            </item>
          </list>
          <para>A string with 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 the 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" />.</para>
          <list type="table">
            <listheader>
              <item>
                <term>
                  <para>NumberStyles value</para>
                </term>
                <description>
                  <para>Elements permitted in <paramref name="value" /> in addition to digits</para>
                </description>
              </item>
            </listheader>
            <item>
              <term>
                <para>
                  <see cref="F:System.Globalization.NumberStyles.None" />
                </para>
              </term>
              <description>
                <para>The digits element only.</para>
              </description>
            </item>
            <item>
              <term>
                <para>
                  <see cref="F:System.Globalization.NumberStyles.AllowDecimalPoint" />
                </para>
              </term>
              <description>
                <para>The decimal point (.) and fractional-digits elements.</para>
              </description>
            </item>
            <item>
              <term>
                <para>
                  <see cref="F:System.Globalization.NumberStyles.AllowExponent" />
                </para>
              </term>
              <description>
                <para>The "e" or "E" character, which indicates exponential notation, along with exponential_digits. </para>
              </description>
            </item>
            <item>
              <term>
                <para>
                  <see cref="F:System.Globalization.NumberStyles.AllowLeadingWhite" />
                </para>
              </term>
              <description>
                <para>The ws element at the start of <paramref name="value" />.</para>
              </description>
            </item>
            <item>
              <term>
                <para>
                  <see cref="F:System.Globalization.NumberStyles.AllowTrailingWhite" />
                </para>
              </term>
              <description>
                <para>The ws element at the end of <paramref name="value" />.</para>
              </description>
            </item>
            <item>
              <term>
                <para>
                  <see cref="F:System.Globalization.NumberStyles.AllowLeadingSign" />
                </para>
              </term>
              <description>
                <para>The sign element at the start of <paramref name="value" />. </para>
              </description>
            </item>
            <item>
              <term>
                <para>
                  <see cref="F:System.Globalization.NumberStyles.AllowTrailingSign" />
                </para>
              </term>
              <description>
                <para>The sign element at the end of <paramref name="value" />.</para>
              </description>
            </item>
            <item>
              <term>
                <para>
                  <see cref="F:System.Globalization.NumberStyles.AllowParentheses" />
                </para>
              </term>
              <description>
                <para>The sign element in the form of parentheses enclosing the numeric value.</para>
              </description>
            </item>
            <item>
              <term>
                <para>
                  <see cref="F:System.Globalization.NumberStyles.AllowThousands" />
                </para>
              </term>
              <description>
                <para>The group separator (,) element.</para>
              </description>
            </item>
            <item>
              <term>
                <para>
                  <see cref="F:System.Globalization.NumberStyles.AllowCurrencySymbol" />
                </para>
              </term>
              <description>
                <para>The currency ($) element.</para>
              </description>
            </item>
            <item>
              <term>
                <para>
                  <see cref="F:System.Globalization.NumberStyles.Currency" />
                </para>
              </term>
              <description>
                <para>All elements. However, <paramref name="value" /> cannot represent a hexadecimal number or a number in exponential notation.</para>
              </description>
            </item>
            <item>
              <term>
                <para>
                  <see cref="F:System.Globalization.NumberStyles.Float" />
                </para>
              </term>
              <description>
                <para>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.</para>
              </description>
            </item>
            <item>
              <term>
                <para>
                  <see cref="F:System.Globalization.NumberStyles.Number" />
                </para>
              </term>
              <description>
                <para>The <paramref name="ws" />, <paramref name="sign" />, group separator (,), and decimal point (.) elements.</para>
              </description>
            </item>
            <item>
              <term>
                <para>
                  <see cref="F:System.Globalization.NumberStyles.Any" />
                </para>
              </term>
              <description>
                <para>All elements. However, <paramref name="value" /> cannot represent a hexadecimal number.</para>
              </description>
            </item>
          </list>
          <block subset="none" type="note">
            <para>If you use the <see cref="M:System.Numerics.BigInteger.Parse(System.String)" /> method to round-trip the string representation of a <see cref="T:System.Numerics.BigInteger" /> value that was output by the <see cref="Overload:System.Numerics.BigInteger.ToString" /> method, you should use the <see cref="M:System.Numerics.BigInteger.ToString(System.String)" /> method with the "R" format specifier to generate the string representation of the <see cref="T:System.Numerics.BigInteger" /> value. Otherwise, the string representation of the <see cref="T:System.Numerics.BigInteger" /> preserves only the 50 most significant digits of the original value, and data may be lost when you use the <see cref="M:System.Numerics.BigInteger.Parse(System.String)" /> method to restore the <see cref="T:System.Numerics.BigInteger" /> value.</para>
          </block>
          <para>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.)</para>
          <block subset="none" type="note">
            <para>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.</para>
          </block>
          <para>If <paramref name="value" /> is a hexadecimal string, the <see cref="M:System.Numerics.BigInteger.Parse(System.String,System.Globalization.NumberStyles)" /> 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. The following example illustrates the difference between hexadecimal strings that represent negative and positive values.</para>
          <para>code reference: System.Numerics.BigInteger.Parse#3</para>
          <para>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:System.Numerics.BigInteger.Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider)" /> overload.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Converts the string representation of a number in a specified style to its <see cref="T:System.Numerics.BigInteger" /> equivalent.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>A value that is equivalent to the number specified in the <paramref name="value" /> parameter.</para>
        </returns>
        <param name="value">
          <attribution license="cc4" from="Microsoft" modified="false" />A string that contains a number to convert. </param>
        <param name="style">
          <attribution license="cc4" from="Microsoft" modified="false" />A bitwise combination of the enumeration values that specify the permitted format of <paramref name="value" />.</param>
      </Docs>
    </Member>
    <Member MemberName="Parse">
      <MemberSignature Language="C#" Value="public static System.Numerics.BigInteger Parse (string value, IFormatProvider provider);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig valuetype System.Numerics.BigInteger Parse(string value, class System.IFormatProvider provider) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Numerics.BigInteger</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.String" />
        <Parameter Name="provider" Type="System.IFormatProvider" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The <paramref name="value" /> parameter should be the string representation of a number in the following 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>
              <item>
                <term>
                  <para>Element</para>
                </term>
                <description>
                  <para>Description</para>
                </description>
              </item>
            </listheader>
            <item>
              <term>
                <para>ws</para>
              </term>
              <description>
                <para>Optional white space.</para>
              </description>
            </item>
            <item>
              <term>
                <para>sign</para>
              </term>
              <description>
                <para>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 <see cref="T:System.Globalization.NumberFormatInfo" /> object that is returned by the <paramref name="provider" /> object's <see cref="M:System.IFormatProvider.GetFormat(System.Type)" /> method.</para>
              </description>
            </item>
            <item>
              <term>
                <para>digits</para>
              </term>
              <description>
                <para>A sequence of digits ranging from 0 to 9. Any leading zeros are ignored.</para>
              </description>
            </item>
          </list>
          <block subset="none" type="note">
            <para>The string specified by 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.</para>
          </block>
          <block subset="none" type="note">
            <para>If you use the <see cref="M:System.Numerics.BigInteger.Parse(System.String)" /> method to round-trip the string representation of a <see cref="T:System.Numerics.BigInteger" /> value that was output by the <see cref="Overload:System.Numerics.BigInteger.ToString" /> method, you should use the <see cref="M:System.Numerics.BigInteger.ToString(System.String)" /> method with the "R" format specifier to generate the string representation of the <see cref="T:System.Numerics.BigInteger" /> value. Otherwise, the string representation of the <see cref="T:System.Numerics.BigInteger" /> preserves only the 50 most significant digits of the original value, and data may be lost when you use the <see cref="M:System.Numerics.BigInteger.Parse(System.String)" /> method to restore the <see cref="T:System.Numerics.BigInteger" /> value.</para>
          </block>
          <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 formatting information. When the <see cref="M:System.Numerics.BigInteger.Parse(System.String,System.IFormatProvider)" /> method is invoked, it calls the <paramref name="provider" /> 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 about the format of the <paramref name="value" /> parameter. 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>
              <para>You can pass a <see cref="T:System.Globalization.CultureInfo" /> object that represents the culture that supplies 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 for that culture.</para>
            </item>
            <item>
              <para>You can pass the actual <see cref="T:System.Globalization.NumberFormatInfo" /> object that provides numeric formatting information. (Its implementation of <see cref="M:System.Globalization.NumberFormatInfo.GetFormat(System.Type)" /> just returns itself.)</para>
            </item>
            <item>
              <para>You can pass a custom object that implements <see cref="T:System.IFormatProvider" />. Its <see cref="M:System.IFormatProvider.GetFormat(System.Type)" /> method instantiates and returns the <see cref="T:System.Globalization.NumberFormatInfo" /> object that provides formatting information.</para>
            </item>
          </list>
          <para>If <paramref name="provider" /> is null, the formatting of <paramref name="value" /> is interpreted based on the <see cref="T:System.Globalization.NumberFormatInfo" /> object of the current culture.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Converts the string representation of a number in a specified culture-specific format to its <see cref="T:System.Numerics.BigInteger" /> equivalent.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>A value that is equivalent to the number specified in the <paramref name="value" /> parameter.</para>
        </returns>
        <param name="value">
          <attribution license="cc4" from="Microsoft" modified="false" />A string that contains a number to convert.</param>
        <param name="provider">
          <attribution license="cc4" from="Microsoft" modified="false" />An object that provides culture-specific formatting information about <paramref name="value" />.</param>
      </Docs>
    </Member>
    <Member MemberName="Parse">
      <MemberSignature Language="C#" Value="public static System.Numerics.BigInteger Parse (string value, System.Globalization.NumberStyles style, IFormatProvider provider);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig valuetype System.Numerics.BigInteger Parse(string value, valuetype System.Globalization.NumberStyles style, class System.IFormatProvider provider) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Numerics.BigInteger</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.String" />
        <Parameter Name="style" Type="System.Globalization.NumberStyles" />
        <Parameter Name="provider" Type="System.IFormatProvider" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>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="styles" /> 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 <paramref name="value" /> is known only at run time, or when you want to disallow white space or a sign symbol in <paramref name="value" />.</para>
          <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>
              <item>
                <term>
                  <para>Element</para>
                </term>
                <description>
                  <para>Description</para>
                </description>
              </item>
            </listheader>
            <item>
              <term>
                <para>ws</para>
              </term>
              <description>
                <para>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="value" /> if <paramref name="style" /> includes the <see cref="F:System.Globalization.NumberStyles.AllowTrailingWhite" /> flag.</para>
              </description>
            </item>
            <item>
              <term>
                <para>$</para>
              </term>
              <description>
                <para>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 <paramref name="value" /> if <paramref name="style" /> includes the <see cref="F:System.Globalization.NumberStyles.AllowCurrencySymbol" /> flag.</para>
              </description>
            </item>
            <item>
              <term>
                <para>sign</para>
              </term>
              <description>
                <para>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. </para>
              </description>
            </item>
            <item>
              <term>
                <para>digits</para>
                <para>fractional_digits</para>
                <para>exponential_digits</para>
              </term>
              <description>
                <para>A sequence of digits from 0 through 9. For fractional_digits, only the digit 0 is valid.</para>
              </description>
            </item>
            <item>
              <term>
                <para>,</para>
              </term>
              <description>
                <para>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.</para>
              </description>
            </item>
            <item>
              <term>
                <para>.</para>
              </term>
              <description>
                <para>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.</para>
              </description>
            </item>
            <item>
              <term>
                <para>E</para>
              </term>
              <description>
                <para>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.</para>
              </description>
            </item>
            <item>
              <term>
                <para>hexdigits</para>
              </term>
              <description>
                <para>A sequence of hexadecimal digits from 0 through f, or 0 through F. </para>
              </description>
            </item>
          </list>
          <para>A string with 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 the 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" />.</para>
          <list type="table">
            <listheader>
              <item>
                <term>
                  <para>NumberStyles value</para>
                </term>
                <description>
                  <para>Elements permitted in value in addition to digits</para>
                </description>
              </item>
            </listheader>
            <item>
              <term>
                <para>
                  <see cref="F:System.Globalization.NumberStyles.None" />
                </para>
              </term>
              <description>
                <para>The digits element only.</para>
              </description>
            </item>
            <item>
              <term>
                <para>
                  <see cref="F:System.Globalization.NumberStyles.AllowDecimalPoint" />
                </para>
              </term>
              <description>
                <para>The decimal point (.) and fractional-digits elements.</para>
              </description>
            </item>
            <item>
              <term>
                <para>
                  <see cref="F:System.Globalization.NumberStyles.AllowExponent" />
                </para>
              </term>
              <description>
                <para>The "e" or "E" character, which indicates exponential notation. along with exponential_digits. </para>
              </description>
            </item>
            <item>
              <term>
                <para>
                  <see cref="F:System.Globalization.NumberStyles.AllowLeadingWhite" />
                </para>
              </term>
              <description>
                <para>The ws element at the start of <paramref name="value" />.</para>
              </description>
            </item>
            <item>
              <term>
                <para>
                  <see cref="F:System.Globalization.NumberStyles.AllowTrailingWhite" />
                </para>
              </term>
              <description>
                <para>The ws element at the end of <paramref name="value" />.</para>
              </description>
            </item>
            <item>
              <term>
                <para>
                  <see cref="F:System.Globalization.NumberStyles.AllowLeadingSign" />
                </para>
              </term>
              <description>
                <para>The sign element at the start of <paramref name="value" />.</para>
              </description>
            </item>
            <item>
              <term>
                <para>
                  <see cref="F:System.Globalization.NumberStyles.AllowTrailingSign" />
                </para>
              </term>
              <description>
                <para>The sign element at the end of <paramref name="value" />.</para>
              </description>
            </item>
            <item>
              <term>
                <para>
                  <see cref="F:System.Globalization.NumberStyles.AllowParentheses" />
                </para>
              </term>
              <description>
                <para>The sign element in the form of parentheses enclosing the numeric value.</para>
              </description>
            </item>
            <item>
              <term>
                <para>
                  <see cref="F:System.Globalization.NumberStyles.AllowThousands" />
                </para>
              </term>
              <description>
                <para>The group separator (,) element.</para>
              </description>
            </item>
            <item>
              <term>
                <para>
                  <see cref="F:System.Globalization.NumberStyles.AllowCurrencySymbol" />
                </para>
              </term>
              <description>
                <para>The currency ($) element.</para>
              </description>
            </item>
            <item>
              <term>
                <para>
                  <see cref="F:System.Globalization.NumberStyles.Currency" />
                </para>
              </term>
              <description>
                <para>All elements. However, <paramref name="value" /> cannot represent a hexadecimal number or a number in exponential notation.</para>
              </description>
            </item>
            <item>
              <term>
                <para>
                  <see cref="F:System.Globalization.NumberStyles.Float" />
                </para>
              </term>
              <description>
                <para>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.</para>
              </description>
            </item>
            <item>
              <term>
                <para>
                  <see cref="F:System.Globalization.NumberStyles.Number" />
                </para>
              </term>
              <description>
                <para>The <paramref name="ws" />, <paramref name="sign" />, group separator (,), and decimal point (.) elements.</para>
              </description>
            </item>
            <item>
              <term>
                <para>
                  <see cref="F:System.Globalization.NumberStyles.Any" />
                </para>
              </term>
              <description>
                <para>All elements. However, <paramref name="value" /> cannot represent a hexadecimal number.</para>
              </description>
            </item>
          </list>
          <block subset="none" type="note">
            <para>If you use the <see cref="M:System.Numerics.BigInteger.Parse(System.String)" /> method to round-trip the string representation of a <see cref="T:System.Numerics.BigInteger" /> value that was output by the <see cref="Overload:System.Numerics.BigInteger.ToString" /> method, you should use the <see cref="M:System.Numerics.BigInteger.ToString(System.String)" /> method with the "R" format specifier to generate the string representation of the <see cref="T:System.Numerics.BigInteger" /> value. Otherwise, the string representation of the <see cref="T:System.Numerics.BigInteger" /> preserves only the 50 most significant digits of the original value, and data may be lost when you use the <see cref="M:System.Numerics.BigInteger.Parse(System.String)" /> method to restore the <see cref="T:System.Numerics.BigInteger" /> value.</para>
          </block>
          <para>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.)</para>
          <block subset="none" type="note">
            <para>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.</para>
          </block>
          <para>If <paramref name="value" /> is a hexadecimal string, the <see cref="M:System.Numerics.BigInteger.Parse(System.String,System.Globalization.NumberStyles)" /> 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. The following example illustrates the difference between hexadecimal strings that represent negative and positive values.</para>
          <para>code reference: System.Numerics.BigInteger.Parse#3</para>
          <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 <paramref name="value" />. Typically, <paramref name="provider" /> can be any one of the following: </para>
          <list type="bullet">
            <item>
              <para>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.</para>
            </item>
            <item>
              <para>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.)</para>
            </item>
            <item>
              <para>A custom object that implements <see cref="T:System.IFormatProvider" /> and uses the <see cref="M:System.Globalization.NumberFormatInfo.GetFormat(System.Type)" /> method to instantiate and return the <see cref="T:System.Globalization.NumberFormatInfo" /> object that provides formatting information.</para>
            </item>
          </list>
          <para>If <paramref name="provider" /> is null, the <see cref="T:System.Globalization.NumberFormatInfo" /> object for the current culture is used.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Converts the string representation of a number in a specified style and culture-specific format to its <see cref="T:System.Numerics.BigInteger" /> equivalent.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>A value that is equivalent to the number specified in the <paramref name="value" /> parameter.</para>
        </returns>
        <param name="value">
          <attribution license="cc4" from="Microsoft" modified="false" />A string that contains a number to convert.</param>
        <param name="style">
          <attribution license="cc4" from="Microsoft" modified="false" />A bitwise combination of the enumeration values that specify the permitted format of <paramref name="value" />.</param>
        <param name="provider">
          <attribution license="cc4" from="Microsoft" modified="false" />An object that provides culture-specific formatting information about <paramref name="value" />.</param>
      </Docs>
    </Member>
    <Member MemberName="Pow">
      <MemberSignature Language="C#" Value="public static System.Numerics.BigInteger Pow (System.Numerics.BigInteger value, int exponent);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig valuetype System.Numerics.BigInteger Pow(valuetype System.Numerics.BigInteger value, int32 exponent) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Numerics.BigInteger</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.Numerics.BigInteger" />
        <Parameter Name="exponent" Type="System.Int32" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The <see cref="M:System.Numerics.BigInteger.Pow(System.Numerics.BigInteger,System.Int32)" /> method returns 1 if the value of the exponent parameter is 0, or if the values of both the <paramref name="value" /> and <paramref name="exponent" /> parameters are 0. If <paramref name="exponent" /> is 1, the <see cref="M:System.Numerics.BigInteger.Pow(System.Numerics.BigInteger,System.Int32)" /> method returns <paramref name="value" />. If <paramref name="value" /> is negative, the method returns a negative result.</para>
          <para>This method corresponds to the <see cref="M:System.Math.Pow(System.Double,System.Double)" /> method for primitive numeric types.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Raises a <see cref="T:System.Numerics.BigInteger" /> value to the power of a specified value.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The result of raising <paramref name="value" /> to the <paramref name="exponent" /> power.</para>
        </returns>
        <param name="value">
          <attribution license="cc4" from="Microsoft" modified="false" />The number to raise to the <paramref name="exponent" /> power.</param>
        <param name="exponent">
          <attribution license="cc4" from="Microsoft" modified="false" />The exponent to raise <paramref name="value" /> by.</param>
      </Docs>
    </Member>
    <Member MemberName="Remainder">
      <MemberSignature Language="C#" Value="public static System.Numerics.BigInteger Remainder (System.Numerics.BigInteger dividend, System.Numerics.BigInteger divisor);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig valuetype System.Numerics.BigInteger Remainder(valuetype System.Numerics.BigInteger dividend, valuetype System.Numerics.BigInteger divisor) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Numerics.BigInteger</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="dividend" Type="System.Numerics.BigInteger" />
        <Parameter Name="divisor" Type="System.Numerics.BigInteger" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The sign of the remainder is the sign of the <paramref name="dividend" /> parameter.</para>
          <para>The <see cref="M:System.Numerics.BigInteger.Remainder(System.Numerics.BigInteger,System.Numerics.BigInteger)" /> method is implemented for languages that do not support custom operators. Its behavior is identical to division using the modulus operator.</para>
          <para>If necessary, the method automatically performs implicit conversion of other integral types to <see cref="T:System.Numerics.BigInteger" /> objects before it performs the modulus operation. </para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Performs integer division on two <see cref="T:System.Numerics.BigInteger" /> values and returns the remainder.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The remainder after dividing <paramref name="dividend" /> by <paramref name="divisor" />.</para>
        </returns>
        <param name="dividend">
          <attribution license="cc4" from="Microsoft" modified="false" />The value to be divided.</param>
        <param name="divisor">
          <attribution license="cc4" from="Microsoft" modified="false" />The value to divide by.</param>
      </Docs>
    </Member>
    <Member MemberName="Sign">
      <MemberSignature Language="C#" Value="public int Sign { get; }" />
      <MemberSignature Language="ILAsm" Value=".property instance int32 Sign" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Docs>
        <value>To be added.</value>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The <see cref="P:System.Numerics.BigInteger.Sign" /> property is equivalent to the <see cref="M:System.Math.Sign(System.Int32)" /> method for the primitive numeric types.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Gets a number that indicates the sign (negative, positive, or zero) of the current <see cref="T:System.Numerics.BigInteger" /> object.</para>
        </summary>
      </Docs>
    </Member>
    <Member MemberName="Subtract">
      <MemberSignature Language="C#" Value="public static System.Numerics.BigInteger Subtract (System.Numerics.BigInteger left, System.Numerics.BigInteger right);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig valuetype System.Numerics.BigInteger Subtract(valuetype System.Numerics.BigInteger left, valuetype System.Numerics.BigInteger right) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Numerics.BigInteger</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="left" Type="System.Numerics.BigInteger" />
        <Parameter Name="right" Type="System.Numerics.BigInteger" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Languages that do not support custom operators can use the <see cref="M:System.Numerics.BigInteger.Subtract(System.Numerics.BigInteger,System.Numerics.BigInteger)" /> method to perform subtraction using <see cref="T:System.Numerics.BigInteger" /> values. </para>
          <para>The <see cref="M:System.Numerics.BigInteger.Subtract(System.Numerics.BigInteger,System.Numerics.BigInteger)" /> method is a useful substitute for the subtraction operator when instantiating a <see cref="T:System.Numerics.BigInteger" /> variable by assigning it the difference that results from subtraction, as shown in the following example.</para>
          <para>code reference: System.Numerics.BigInteger.OperationMethods#3</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Subtracts one <see cref="T:System.Numerics.BigInteger" /> value from another and returns the result.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The result of subtracting <paramref name="right" /> from <paramref name="left" />.</para>
        </returns>
        <param name="left">
          <attribution license="cc4" from="Microsoft" modified="false" />The value to subtract from (the minuend).</param>
        <param name="right">
          <attribution license="cc4" from="Microsoft" modified="false" />The value to subtract (the subtrahend).</param>
      </Docs>
    </Member>
    <Member MemberName="ToByteArray">
      <MemberSignature Language="C#" Value="public byte[] ToByteArray ();" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance unsigned int8[] ToByteArray() cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Byte[]</ReturnType>
      </ReturnValue>
      <Parameters />
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The individual bytes in the array returned by this method appear in little-endian order. That is, the lower-order bytes of the value precede the higher-order bytes. The first byte of the array reflects the first eight bits of the <see cref="T:System.Numerics.BigInteger" /> value, the second byte reflects the next eight bits, and so on. For example, the value 1024, or 0x0400, is stored as the following array of two bytes:</para>
          <list type="table">
            <listheader>
              <item>
                <term>
                  <para>Element</para>
                </term>
                <description>
                  <para>Byte value</para>
                </description>
              </item>
            </listheader>
            <item>
              <term>
                <para>0</para>
              </term>
              <description>
                <para>0x00</para>
              </description>
            </item>
            <item>
              <term>
                <para>1</para>
              </term>
              <description>
                <para>0x04</para>
              </description>
            </item>
          </list>
          <para>Negative values are written to the array using two's complement representation in the most compact form possible. For example, -1 is represented as a single byte whose value is 0xFF instead of as an array with multiple elements, such as 0xFF, 0xFF or 0xFF, 0xFF, 0xFF, 0xFF.</para>
          <para>Because two's complement representation always interprets the highest-order bit of the last byte in the array (the byte at position <see cref="P:System.Array.Length" /> - 1) as the sign bit, the method returns a byte array with an extra element whose value is zero to disambiguate positive values that could otherwise be interpreted as having their sign bits set. For example, the value 120 or 0x78 is represented as a single-byte array: 0x78. However, 128, or 0x80, is represented as a two-byte array: 0x80, 0x00. </para>
          <para>You can round-trip a <see cref="T:System.Numerics.BigInteger" /> value by storing it to a byte array and then restoring it using the <see cref="M:System.Numerics.BigInteger.#ctor(System.Byte[])" /> constructor. </para>
          <block subset="none" type="note">
            <para> If your code modifies the value of individual bytes in the array returned by this method before it restores the value, you must make sure that you do not unintentionally change the sign bit. For example, if your modifications increase a positive value so that the highest-order bit in the last element of the byte array becomes set, you can add a new byte whose value is zero to the end of the array.</para>
          </block>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Converts a <see cref="T:System.Numerics.BigInteger" /> value to a byte array.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The value of the current <see cref="T:System.Numerics.BigInteger" /> object converted to an array of bytes.</para>
        </returns>
      </Docs>
    </Member>
    <Member MemberName="ToString">
      <MemberSignature Language="C#" Value="public override string ToString ();" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual instance string ToString() cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.String</ReturnType>
      </ReturnValue>
      <Parameters />
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The <see cref="M:System.Numerics.BigInteger.ToString" /> method formats a <see cref="T:System.Numerics.BigInteger" /> value in the default ("G", or general) format of the current culture. If you want to specify a different format or culture, use the other overloads of the <see cref="M:System.Numerics.BigInteger.ToString(System.String)" /> method, as follows:</para>
          <list type="table">
            <listheader>
              <item>
                <term>
                  <para>To use format</para>
                </term>
                <description>
                  <para>For culture</para>
                </description>
                <description>
                  <para>Use the overload</para>
                </description>
              </item>
            </listheader>
            <item>
              <term>
                <para>Default ("G") format</para>
              </term>
              <description>
                <para>A specific culture</para>
              </description>
              <description>
                <para>
                  <see cref="M:System.BigInteger.ToString(System.IFormatProvider)" />
                </para>
              </description>
            </item>
            <item>
              <term>
                <para>A specific format</para>
              </term>
              <description>
                <para>Default (current) culture</para>
              </description>
              <description>
                <para>
                  <see cref="M:System.BigInteger.ToString(System.String)" />
                </para>
              </description>
            </item>
            <item>
              <term>
                <para>A specific format</para>
              </term>
              <description>
                <para>A specific culture</para>
              </description>
              <description>
                <para>
                  <see cref="M:System.BigInteger.ToString(System.String,System.IFormatProvider)" />
                </para>
              </description>
            </item>
          </list>
          <para>   </para>
          <para>The string representation of the <see cref="T:System.Numerics.BigInteger" /> value includes a negative sign if its value is negative, and a sequence of digits ranging from 0 to 9 without leading zeros. The negative sign is defined by the <see cref="T:System.Globalization.NumberFormatInfo" /> object for the current culture. </para>
          <para>The <see cref="M:System.Numerics.BigInteger.ToString" /> method supports 50 decimal digits of precision. That is, if the <see cref="T:System.Numerics.BigInteger" /> value has more than 50 digits, only the 50 most significant digits are preserved in the output string; all other digits are replaced with zeros. </para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Converts the numeric value of the current <see cref="T:System.Numerics.BigInteger" /> object to its equivalent string representation.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The string representation of the current <see cref="T:System.Numerics.BigInteger" /> value.</para>
        </returns>
      </Docs>
    </Member>
    <Member MemberName="ToString">
      <MemberSignature Language="C#" Value="public string ToString (IFormatProvider provider);" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance string ToString(class System.IFormatProvider provider) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.String</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="provider" Type="System.IFormatProvider" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The <see cref="M:System.Numerics.BigInteger.ToString(System.IFormatProvider)" /> method formats a <see cref="T:System.Numerics.BigInteger" /> value in the default ("G", or general) format by using the <see cref="T:System.Globalization.NumberFormatInfo" /> object of a specified culture. If you want to specify a different format or the current culture, use the other overloads of the <see cref="M:System.Numerics.BigInteger.ToString(System.String)" /> method, as follows:</para>
          <list type="table">
            <listheader>
              <item>
                <term>
                  <para>To use format</para>
                </term>
                <description>
                  <para>For culture</para>
                </description>
                <description>
                  <para>Use the overload</para>
                </description>
              </item>
            </listheader>
            <item>
              <term>
                <para>Default ("G") format</para>
              </term>
              <description>
                <para>Default (current) culture</para>
              </description>
              <description>
                <para>
                  <see cref="M:System.Numerics.BigInteger.ToString" />
                </para>
              </description>
            </item>
            <item>
              <term>
                <para>A specific format</para>
              </term>
              <description>
                <para>Default (current) culture</para>
              </description>
              <description>
                <para>
                  <see cref="M:System.Numerics.BigInteger.ToString(System.String)" />
                </para>
              </description>
            </item>
            <item>
              <term>
                <para>A specific format</para>
              </term>
              <description>
                <para>A specific culture</para>
              </description>
              <description>
                <para>
                  <see cref="M:System.Numerics.BigInteger.ToString(System.String,System.IFormatProvider)" />
                </para>
              </description>
            </item>
          </list>
          <para>  </para>
          <para>The <see cref="M:System.Numerics.BigInteger.ToString(System.IFormatProvider)" /> method supports 50 decimal digits of precision. That is, if the <see cref="T:System.Numerics.BigInteger" /> value has more than 50 digits, only the 50 most significant digits are preserved in the output string; all other digits are replaced with zeros. </para>
          <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 the string returned by this method. If <paramref name="provider" /> is null, the <see cref="T:System.Numerics.BigInteger" /> value is formatted using the <see cref="T:System.Globalization.NumberFormatInfo" /> object of the current culture. The only property of the <see cref="T:System.Globalization.NumberFormatInfo" /> object that controls the string representation of the <see cref="T:System.Numerics.BigInteger" /> value using the general format specifier is <see cref="P:System.Globalization.NumberFormatInfo.NegativeSign" />, which defines the character that represents the negative sign.</para>
          <para>The <paramref name="provider" /> parameter can be one of the following:</para>
          <list type="bullet">
            <item>
              <para>A <see cref="T:System.Globalization.CultureInfo" /> object that represents the culture that supplies formatting information. </para>
            </item>
            <item>
              <para>The <see cref="T:System.Globalization.NumberFormatInfo" /> object that supplies formatting information.</para>
            </item>
            <item>
              <para>A custom object that implements <see cref="T:System.IFormatProvider" />. Its <see cref="M:System.IFormatProvider.GetFormat(System.Type)" /> method returns the <see cref="T:System.Globalization.NumberFormatInfo" /> object that supplies formatting information. </para>
            </item>
          </list>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Converts the numeric value of the current <see cref="T:System.Numerics.BigInteger" /> object to its equivalent string representation by using the specified culture-specific formatting information.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The string representation of the current <see cref="T:System.Numerics.BigInteger" /> value in the format specified by the <paramref name="provider" /> parameter.</para>
        </returns>
        <param name="provider">
          <attribution license="cc4" from="Microsoft" modified="false" />An object that supplies culture-specific formatting information.</param>
      </Docs>
    </Member>
    <Member MemberName="ToString">
      <MemberSignature Language="C#" Value="public string ToString (string format);" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance string ToString(string format) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.String</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="format" Type="System.String" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The <see cref="M:System.Numerics.BigInteger.ToString(System.String)" /> method formats a <see cref="T:System.Numerics.BigInteger" /> value in a specified format by using a <see cref="T:System.Globalization.NumberFormatInfo" /> object that represents the conventions of the current culture. If you want to use the default ("G", or general) format or specify a different culture, use the other overloads of the <see cref="M:System.Numerics.BigInteger.ToString(System.String)" /> method, as follows:</para>
          <list type="table">
            <listheader>
              <item>
                <term>
                  <para>To use format</para>
                </term>
                <description>
                  <para>For culture</para>
                </description>
                <description>
                  <para>Use the overload</para>
                </description>
              </item>
            </listheader>
            <item>
              <term>
                <para>Default ("G") format</para>
              </term>
              <description>
                <para>Default (current) culture</para>
              </description>
              <description>
                <para>
                  <see cref="M:System.Numerics.BigInteger.ToString" />
                </para>
              </description>
            </item>
            <item>
              <term>
                <para>Default ("G") format</para>
              </term>
              <description>
                <para>A specific culture</para>
              </description>
              <description>
                <para>
                  <see cref="M:System.Numerics.BigInteger.ToString(System.IFormatProvider)" />
                </para>
              </description>
            </item>
            <item>
              <term>
                <para>A specific format</para>
              </term>
              <description>
                <para>A specific culture</para>
              </description>
              <description>
                <para>
                  <see cref="M:System.Numerics.BigInteger.ToString(System.String,System.IFormatProvider)" />
                </para>
              </description>
            </item>
          </list>
          <para>        </para>
          <para>The <paramref name="format" /> parameter can be any valid <format type="text/html"><a href="580e57eb-ac47-4ffd-bccd-3a1637c2f467">standard numeric format specifier</a></format>, or any combination of <format type="text/html"><a href="6f74fd32-6c6b-48ed-8241-3c2b86dea5f4">custom numeric format specifiers</a></format>. If <paramref name="format" /> is equal to <see cref="F:System.String.Empty" /> or is null, the return value of the current <see cref="T:System.Numerics.BigInteger" /> 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>
          <para>In most cases, the <see cref="Overload:System.Numerics.BigInteger.ToString" /> method supports 50 decimal digits of precision. That is, if the <see cref="T:System.Numerics.BigInteger" /> value has more than 50 digits, only the 50 most significant digits are preserved in the output string; all other digits are replaced with zeros. However, <see cref="T:System.Numerics.BigInteger" /> supports the "R" standard format specifier, which is intended to round-trip numeric values. The string returned by the <see cref="M:System.Numerics.BigInteger.ToString(System.String)" /> method with the "R" format string preserves the whole <see cref="T:System.Numerics.BigInteger" /> value and can then be parsed with the <see cref="Overload:System.Numerics.BigInteger.Parse" /> or <see cref="Overload:System.Numerics.BigInteger.TryParse" /> method to restore its original value without any loss of data. The following example illustrates that a string output using the "R" format string can then be parsed by the <see cref="Overload:System.Numerics.BigInteger.Parse" /> method without any data loss.</para>
          <para>code reference: System.Numerics.BigInteger.ToString#2</para>
          <para>The .NET Framework provides extensive formatting support, which is described in greater detail in the following formatting topics:</para>
          <list type="bullet">
            <item>
              <para>For more information about numeric format specifiers, see <format type="text/html"><a href="580e57eb-ac47-4ffd-bccd-3a1637c2f467">Standard Numeric Format Strings</a></format> and <format type="text/html"><a href="6f74fd32-6c6b-48ed-8241-3c2b86dea5f4">Custom Numeric Format Strings</a></format>.</para>
            </item>
            <item>
              <para>For more information about support for formatting in the .NET Framework, see <format type="text/html"><a href="0d1364da-5b30-4d42-8e6b-03378343343f">Formatting Overview</a></format>.</para>
            </item>
          </list>
          <para>The format of the returned string is determined by the <see cref="T:System.Globalization.NumberFormatInfo" /> object for the current culture. Depending on the <paramref name="format" /> parameter, this object controls symbols such as the negative sign, the group separator, and the decimal point symbol in the output string. To provide formatting information for cultures other than the current culture, call the <see cref="M:System.Numerics.BigInteger.ToString(System.String,System.IFormatProvider)" /> overload.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Converts the numeric value of the current <see cref="T:System.Numerics.BigInteger" /> object to its equivalent string representation by using the specified format.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The string representation of the current <see cref="T:System.Numerics.BigInteger" /> value in the format specified by the <paramref name="format" /> parameter.</para>
        </returns>
        <param name="format">
          <attribution license="cc4" from="Microsoft" modified="false" />A standard or custom numeric format string.</param>
      </Docs>
    </Member>
    <Member MemberName="ToString">
      <MemberSignature Language="C#" Value="public string ToString (string format, IFormatProvider provider);" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig newslot virtual instance string ToString(string format, class System.IFormatProvider provider) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.String</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="format" Type="System.String" />
        <Parameter Name="provider" Type="System.IFormatProvider" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The <see cref="M:System.Numerics.BigInteger.ToString(System.String,System.IFormatProvider)" /> method formats a <see cref="T:System.Numerics.BigInteger" /> value in a specified format by using the <see cref="T:System.Globalization.NumberFormatInfo" /> object of a specified culture. If you want to use default format or culture settings, use the other overloads of the <see cref="M:System.Numerics.BigInteger.ToString(System.String)" /> method, as follows:</para>
          <list type="table">
            <listheader>
              <item>
                <term>
                  <para>To use format</para>
                </term>
                <description>
                  <para>For culture</para>
                </description>
                <description>
                  <para>Use the overload</para>
                </description>
              </item>
            </listheader>
            <item>
              <term>
                <para>Default ("G") format</para>
              </term>
              <description>
                <para>Default (current) culture</para>
              </description>
              <description>
                <para>
                  <see cref="M:System.Numerics.BigInteger.ToString" />
                </para>
              </description>
            </item>
            <item>
              <term>
                <para>Default ("G") format</para>
              </term>
              <description>
                <para>A specific culture</para>
              </description>
              <description>
                <para>
                  <see cref="M:System.Numerics.BigInteger.ToString(System.IFormatProvider)" />
                </para>
              </description>
            </item>
            <item>
              <term>
                <para>A specific format</para>
              </term>
              <description>
                <para>Default (current) culture</para>
              </description>
              <description>
                <para>
                  <see cref="M:System.Numerics.BigInteger.ToString(System.String)" />
                </para>
              </description>
            </item>
          </list>
          <para>     </para>
          <para>The <paramref name="format" /> parameter can be any valid <format type="text/html"><a href="580e57eb-ac47-4ffd-bccd-3a1637c2f467">standard numeric format specifier</a></format>, or any combination of <format type="text/html"><a href="6f74fd32-6c6b-48ed-8241-3c2b86dea5f4">custom numeric format specifiers</a></format>. If <paramref name="format" /> is equal to <see cref="F:System.String.Empty" /> or is null, the return value of the current <see cref="T:System.Numerics.BigInteger" /> 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>
          <para>In most cases, the <see cref="Overload:System.Numerics.BigInteger.ToString" /> method supports 50 decimal digits of precision. That is, if the <see cref="T:System.Numerics.BigInteger" /> value has more than 50 digits, only the 50 most significant digits are preserved in the output string; all other digits are replaced with zeros. However, <see cref="T:System.Numerics.BigInteger" /> supports the "R" standard format specifier, which is intended to round-trip numeric values. The string returned by the <see cref="M:System.Numerics.BigInteger.ToString(System.String)" /> method with the "R" format string preserves the whole <see cref="T:System.Numerics.BigInteger" /> value and can then be parsed with the <see cref="Overload:System.Numerics.BigInteger.Parse" /> or <see cref="Overload:System.Numerics.BigInteger.TryParse" /> method to restore its original value without any loss of data. </para>
          <para>The .NET Framework provides extensive formatting support, which is described in greater detail in the following formatting topics:</para>
          <list type="bullet">
            <item>
              <para>For more information about numeric format specifiers, see <format type="text/html"><a href="580e57eb-ac47-4ffd-bccd-3a1637c2f467">Standard Numeric Format Strings</a></format> and <format type="text/html"><a href="6f74fd32-6c6b-48ed-8241-3c2b86dea5f4">Custom Numeric Format Strings</a></format>.</para>
            </item>
            <item>
              <para>For more information about support for formatting in the .NET Framework, see <format type="text/html"><a href="0d1364da-5b30-4d42-8e6b-03378343343f">Formatting Overview</a></format>.</para>
            </item>
          </list>
          <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 the string returned by this method. When the <see cref="M:System.Numerics.BigInteger.ToString(System.String,System.IFormatProvider)" /> method is invoked, it calls the <paramref name="provider" /> 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 <paramref name="value" /> parameter, such as the negative sign symbol, the group separator symbol, or the decimal point symbol. There are three ways to use the <paramref name="provider" /> parameter to supply formatting information to the <see cref="M:System.Numerics.BigInteger.ToString(System.String,System.IFormatProvider)" /> method: </para>
          <list type="bullet">
            <item>
              <para>You can pass a <see cref="T:System.Globalization.CultureInfo" /> object that represents the culture that supplies 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 for that culture.</para>
            </item>
            <item>
              <para>You can pass the actual <see cref="T:System.Globalization.NumberFormatInfo" /> object that provides numeric formatting information. (Its implementation of <see cref="M:System.Globalization.NumberFormatInfo.GetFormat(System.Type)" /> just returns itself.)</para>
            </item>
            <item>
              <para>You can pass a custom object that implements <see cref="T:System.IFormatProvider" />. Its <see cref="M:System.IFormatProvider.GetFormat(System.Type)" /> method instantiates and returns the <see cref="T:System.Globalization.NumberFormatInfo" /> object that provides formatting information.</para>
            </item>
          </list>
          <para>If <paramref name="provider" /> is null, the formatting of the returned string is based on the <see cref="T:System.Globalization.NumberFormatInfo" /> object of the current culture.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Converts the numeric value of the current <see cref="T:System.Numerics.BigInteger" /> object to its equivalent string representation by using the specified format and culture-specific format information.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The string representation of the current <see cref="T:System.Numerics.BigInteger" /> value as specified by the <paramref name="format" /> and <paramref name="provider" /> parameters.</para>
        </returns>
        <param name="format">
          <attribution license="cc4" from="Microsoft" modified="false" />A standard or custom numeric format string.</param>
        <param name="provider">
          <attribution license="cc4" from="Microsoft" modified="false" />An object that supplies culture-specific formatting information.</param>
      </Docs>
    </Member>
    <Member MemberName="TryParse">
      <MemberSignature Language="C#" Value="public static bool TryParse (string value, out System.Numerics.BigInteger result);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig bool TryParse(string value, valuetype System.Numerics.BigInteger result) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.String" />
        <Parameter Name="result" Type="System.Numerics.BigInteger&amp;" RefType="out" />
      </Parameters>
      <Docs>
        <param name="value">To be added.</param>
        <param name="result">To be added.</param>
        <summary>To be added.</summary>
        <returns>To be added.</returns>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="TryParse">
      <MemberSignature Language="C#" Value="public static bool TryParse (string value, System.Globalization.NumberStyles style, IFormatProvider provider, out System.Numerics.BigInteger result);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig bool TryParse(string value, valuetype System.Globalization.NumberStyles style, class System.IFormatProvider provider, valuetype System.Numerics.BigInteger result) cil managed" />
      <MemberType>Method</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="value" Type="System.String" />
        <Parameter Name="style" Type="System.Globalization.NumberStyles" />
        <Parameter Name="provider" Type="System.IFormatProvider" />
        <Parameter Name="result" Type="System.Numerics.BigInteger&amp;" RefType="out" />
      </Parameters>
      <Docs>
        <param name="value">To be added.</param>
        <param name="style">To be added.</param>
        <param name="provider">To be added.</param>
        <param name="result">To be added.</param>
        <summary>To be added.</summary>
        <returns>To be added.</returns>
        <remarks>To be added.</remarks>
      </Docs>
    </Member>
    <Member MemberName="Zero">
      <MemberSignature Language="C#" Value="public static System.Numerics.BigInteger Zero { get; }" />
      <MemberSignature Language="ILAsm" Value=".property valuetype System.Numerics.BigInteger Zero" />
      <MemberType>Property</MemberType>
      <AssemblyInfo>
        <AssemblyVersion>4.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <ReturnValue>
        <ReturnType>System.Numerics.BigInteger</ReturnType>
      </ReturnValue>
      <Docs>
        <value>To be added.</value>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The <see cref="T:System.Numerics.BigInteger" /> object returned by this property provides a convenient source of a zero value for use in assignments and comparisons.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Gets a value that represents the number 0 (zero).</para>
        </summary>
      </Docs>
    </Member>
  </Members>
</Type>